librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 static enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 4));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 516 {
 517         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 518         return NDR_ERR_SUCCESS;
 519 }
 520
 521 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 522 {
 523         uint32_t v;
 524         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 525         *r = v;
 526         return NDR_ERR_SUCCESS;
 527 }
 528
 529 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 530 {
 531         ndr_print_uint32(ndr, name, r);
 532         ndr->depth++;
 533         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 534         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 535         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 536         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 537         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 561         ndr->depth--;
 562 }
 563
 564 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 565 {
 566         if (ndr_flags & NDR_SCALARS) {
 567                 NDR_CHECK(ndr_push_align(ndr, 4));
 568                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 569                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 570                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 571                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 572                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 573                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 578                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 587                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 589                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 602                 {
 603                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 605                         {
 606                                 struct ndr_push *_ndr_driverextra_data;
 607                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 608                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 609                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 610                         }
 611                         ndr->flags = _flags_save_DATA_BLOB;
 612                 }
 613         }
 614         if (ndr_flags & NDR_BUFFERS) {
 615         }
 616         return NDR_ERR_SUCCESS;
 617 }
 618
 619 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 620 {
 621         if (ndr_flags & NDR_SCALARS) {
 622                 NDR_CHECK(ndr_pull_align(ndr, 4));
 623                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 624                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 625                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 626                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 627                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 628                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 633                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 642                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 644                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 645                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 648                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 657                 {
 658                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 660                         {
 661                                 struct ndr_pull *_ndr_driverextra_data;
 662                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 663                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 664                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 665                         }
 666                         ndr->flags = _flags_save_DATA_BLOB;
 667                 }
 668         }
 669         if (ndr_flags & NDR_BUFFERS) {
 670         }
 671         return NDR_ERR_SUCCESS;
 672 }
 673
 674 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 675 {
 676         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 677         ndr->depth++;
 678         ndr_print_string(ndr, "devicename", r->devicename);
 679         ndr_print_uint16(ndr, "specversion", r->specversion);
 680         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 681         ndr_print_uint16(ndr, "size", r->size);
 682         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 683         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 684         ndr_print_uint16(ndr, "orientation", r->orientation);
 685         ndr_print_uint16(ndr, "papersize", r->papersize);
 686         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 687         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 688         ndr_print_uint16(ndr, "scale", r->scale);
 689         ndr_print_uint16(ndr, "copies", r->copies);
 690         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 691         ndr_print_uint16(ndr, "printquality", r->printquality);
 692         ndr_print_uint16(ndr, "color", r->color);
 693         ndr_print_uint16(ndr, "duplex", r->duplex);
 694         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 695         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 696         ndr_print_uint16(ndr, "collate", r->collate);
 697         ndr_print_string(ndr, "formname", r->formname);
 698         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 699         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 700         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 701         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 702         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 703         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 704         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 705         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 706         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 707         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 708         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 709         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 710         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 711         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 712         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 713         ndr->depth--;
 714 }
 715
 716 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 717 {
 718         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 719 }
 720
 721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 722 {
 723         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 724         return NDR_ERR_SUCCESS;
 725 }
 726
 727 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 728 {
 729         uint32_t v;
 730         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 731         *r = v;
 732         return NDR_ERR_SUCCESS;
 733 }
 734
 735 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 736 {
 737         ndr_print_uint32(ndr, name, r);
 738         ndr->depth++;
 739         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 740         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 741         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 742         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 743         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 758         ndr->depth--;
 759 }
 760
 761 static enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 762 {
 763         if (ndr_flags & NDR_SCALARS) {
 764                 NDR_CHECK(ndr_push_align(ndr, 4));
 765                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 766                 {
 767                         uint32_t _flags_save_string = ndr->flags;
 768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 769                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 770                         ndr->flags = _flags_save_string;
 771                 }
 772                 {
 773                         uint32_t _flags_save_string = ndr->flags;
 774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 775                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 776                         ndr->flags = _flags_save_string;
 777                 }
 778                 {
 779                         uint32_t _flags_save_string = ndr->flags;
 780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 782                         ndr->flags = _flags_save_string;
 783                 }
 784         }
 785         if (ndr_flags & NDR_BUFFERS) {
 786                 {
 787                         uint32_t _flags_save_string = ndr->flags;
 788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 789                         if (r->name) {
 790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 792                         }
 793                         ndr->flags = _flags_save_string;
 794                 }
 795                 {
 796                         uint32_t _flags_save_string = ndr->flags;
 797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 798                         if (r->description) {
 799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 801                         }
 802                         ndr->flags = _flags_save_string;
 803                 }
 804                 {
 805                         uint32_t _flags_save_string = ndr->flags;
 806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 807                         if (r->comment) {
 808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 810                         }
 811                         ndr->flags = _flags_save_string;
 812                 }
 813         }
 814         return NDR_ERR_SUCCESS;
 815 }
 816
 817 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 818 {
 819         uint32_t _ptr_name;
 820         TALLOC_CTX *_mem_save_name_0;
 821         uint32_t _ptr_description;
 822         TALLOC_CTX *_mem_save_description_0;
 823         uint32_t _ptr_comment;
 824         TALLOC_CTX *_mem_save_comment_0;
 825         if (ndr_flags & NDR_SCALARS) {
 826                 NDR_CHECK(ndr_pull_align(ndr, 4));
 827                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 828                 {
 829                         uint32_t _flags_save_string = ndr->flags;
 830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 832                         if (_ptr_name) {
 833                                 NDR_PULL_ALLOC(ndr, r->name);
 834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 835                         } else {
 836                                 r->name = NULL;
 837                         }
 838                         ndr->flags = _flags_save_string;
 839                 }
 840                 {
 841                         uint32_t _flags_save_string = ndr->flags;
 842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 843                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 844                         if (_ptr_description) {
 845                                 NDR_PULL_ALLOC(ndr, r->description);
 846                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 847                         } else {
 848                                 r->description = NULL;
 849                         }
 850                         ndr->flags = _flags_save_string;
 851                 }
 852                 {
 853                         uint32_t _flags_save_string = ndr->flags;
 854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 856                         if (_ptr_comment) {
 857                                 NDR_PULL_ALLOC(ndr, r->comment);
 858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 859                         } else {
 860                                 r->comment = NULL;
 861                         }
 862                         ndr->flags = _flags_save_string;
 863                 }
 864         }
 865         if (ndr_flags & NDR_BUFFERS) {
 866                 {
 867                         uint32_t _flags_save_string = ndr->flags;
 868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 869                         if (r->name) {
 870                                 uint32_t _relative_save_offset;
 871                                 _relative_save_offset = ndr->offset;
 872                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 873                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 874                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 875                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 876                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 877                                 ndr->offset = _relative_save_offset;
 878                         }
 879                         ndr->flags = _flags_save_string;
 880                 }
 881                 {
 882                         uint32_t _flags_save_string = ndr->flags;
 883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 884                         if (r->description) {
 885                                 uint32_t _relative_save_offset;
 886                                 _relative_save_offset = ndr->offset;
 887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 888                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 889                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 892                                 ndr->offset = _relative_save_offset;
 893                         }
 894                         ndr->flags = _flags_save_string;
 895                 }
 896                 {
 897                         uint32_t _flags_save_string = ndr->flags;
 898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 899                         if (r->comment) {
 900                                 uint32_t _relative_save_offset;
 901                                 _relative_save_offset = ndr->offset;
 902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 903                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 904                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 907                                 ndr->offset = _relative_save_offset;
 908                         }
 909                         ndr->flags = _flags_save_string;
 910                 }
 911         }
 912         return NDR_ERR_SUCCESS;
 913 }
 914
 915 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 916 {
 917         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 918         ndr->depth++;
 919         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 920         ndr_print_ptr(ndr, "name", r->name);
 921         ndr->depth++;
 922         if (r->name) {
 923                 ndr_print_string(ndr, "name", r->name);
 924         }
 925         ndr->depth--;
 926         ndr_print_ptr(ndr, "description", r->description);
 927         ndr->depth++;
 928         if (r->description) {
 929                 ndr_print_string(ndr, "description", r->description);
 930         }
 931         ndr->depth--;
 932         ndr_print_ptr(ndr, "comment", r->comment);
 933         ndr->depth++;
 934         if (r->comment) {
 935                 ndr_print_string(ndr, "comment", r->comment);
 936         }
 937         ndr->depth--;
 938         ndr->depth--;
 939 }
 940
 941 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 942 {
 943         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 944         return NDR_ERR_SUCCESS;
 945 }
 946
 947 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 948 {
 949         uint32_t v;
 950         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 951         *r = v;
 952         return NDR_ERR_SUCCESS;
 953 }
 954
 955 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 956 {
 957         ndr_print_uint32(ndr, name, r);
 958         ndr->depth++;
 959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 964         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 968         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 975         ndr->depth--;
 976 }
 977
 978 static enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 979 {
 980         if (ndr_flags & NDR_SCALARS) {
 981                 NDR_CHECK(ndr_push_align(ndr, 4));
 982                 {
 983                         uint32_t _flags_save_string = ndr->flags;
 984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 985                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 986                         ndr->flags = _flags_save_string;
 987                 }
 988                 {
 989                         uint32_t _flags_save_string = ndr->flags;
 990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 991                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 992                         ndr->flags = _flags_save_string;
 993                 }
 994                 {
 995                         uint32_t _flags_save_string = ndr->flags;
 996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 997                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
 998                         ndr->flags = _flags_save_string;
 999                 }
1000                 {
1001                         uint32_t _flags_save_string = ndr->flags;
1002                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1003                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1004                         ndr->flags = _flags_save_string;
1005                 }
1006                 {
1007                         uint32_t _flags_save_string = ndr->flags;
1008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1009                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1010                         ndr->flags = _flags_save_string;
1011                 }
1012                 {
1013                         uint32_t _flags_save_string = ndr->flags;
1014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1015                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1016                         ndr->flags = _flags_save_string;
1017                 }
1018                 {
1019                         uint32_t _flags_save_string = ndr->flags;
1020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1021                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1022                         ndr->flags = _flags_save_string;
1023                 }
1024                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1025                 {
1026                         uint32_t _flags_save_string = ndr->flags;
1027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1028                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1029                         ndr->flags = _flags_save_string;
1030                 }
1031                 {
1032                         uint32_t _flags_save_string = ndr->flags;
1033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1034                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1035                         ndr->flags = _flags_save_string;
1036                 }
1037                 {
1038                         uint32_t _flags_save_string = ndr->flags;
1039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1040                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1041                         ndr->flags = _flags_save_string;
1042                 }
1043                 {
1044                         uint32_t _flags_save_string = ndr->flags;
1045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1046                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1047                         ndr->flags = _flags_save_string;
1048                 }
1049                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1050                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1053                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1055                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1058         }
1059         if (ndr_flags & NDR_BUFFERS) {
1060                 {
1061                         uint32_t _flags_save_string = ndr->flags;
1062                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1063                         if (r->servername) {
1064                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1065                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1066                         }
1067                         ndr->flags = _flags_save_string;
1068                 }
1069                 {
1070                         uint32_t _flags_save_string = ndr->flags;
1071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1072                         if (r->printername) {
1073                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1074                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1075                         }
1076                         ndr->flags = _flags_save_string;
1077                 }
1078                 {
1079                         uint32_t _flags_save_string = ndr->flags;
1080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1081                         if (r->sharename) {
1082                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1083                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1084                         }
1085                         ndr->flags = _flags_save_string;
1086                 }
1087                 {
1088                         uint32_t _flags_save_string = ndr->flags;
1089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1090                         if (r->portname) {
1091                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1092                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1093                         }
1094                         ndr->flags = _flags_save_string;
1095                 }
1096                 {
1097                         uint32_t _flags_save_string = ndr->flags;
1098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1099                         if (r->drivername) {
1100                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1101                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1102                         }
1103                         ndr->flags = _flags_save_string;
1104                 }
1105                 {
1106                         uint32_t _flags_save_string = ndr->flags;
1107                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1108                         if (r->comment) {
1109                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1110                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1111                         }
1112                         ndr->flags = _flags_save_string;
1113                 }
1114                 {
1115                         uint32_t _flags_save_string = ndr->flags;
1116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1117                         if (r->location) {
1118                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1119                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1120                         }
1121                         ndr->flags = _flags_save_string;
1122                 }
1123                 if (r->devmode) {
1124                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1125                         {
1126                                 struct ndr_push *_ndr_devmode;
1127                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1128                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1129                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1130                         }
1131                 }
1132                 {
1133                         uint32_t _flags_save_string = ndr->flags;
1134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1135                         if (r->sepfile) {
1136                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1137                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1138                         }
1139                         ndr->flags = _flags_save_string;
1140                 }
1141                 {
1142                         uint32_t _flags_save_string = ndr->flags;
1143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1144                         if (r->printprocessor) {
1145                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1146                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1147                         }
1148                         ndr->flags = _flags_save_string;
1149                 }
1150                 {
1151                         uint32_t _flags_save_string = ndr->flags;
1152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1153                         if (r->datatype) {
1154                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1155                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1156                         }
1157                         ndr->flags = _flags_save_string;
1158                 }
1159                 {
1160                         uint32_t _flags_save_string = ndr->flags;
1161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1162                         if (r->parameters) {
1163                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1165                         }
1166                         ndr->flags = _flags_save_string;
1167                 }
1168                 if (r->secdesc) {
1169                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1170                         {
1171                                 struct ndr_push *_ndr_secdesc;
1172                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1173                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1174                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1175                         }
1176                 }
1177         }
1178         return NDR_ERR_SUCCESS;
1179 }
1180
1181 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1182 {
1183         uint32_t _ptr_servername;
1184         TALLOC_CTX *_mem_save_servername_0;
1185         uint32_t _ptr_printername;
1186         TALLOC_CTX *_mem_save_printername_0;
1187         uint32_t _ptr_sharename;
1188         TALLOC_CTX *_mem_save_sharename_0;
1189         uint32_t _ptr_portname;
1190         TALLOC_CTX *_mem_save_portname_0;
1191         uint32_t _ptr_drivername;
1192         TALLOC_CTX *_mem_save_drivername_0;
1193         uint32_t _ptr_comment;
1194         TALLOC_CTX *_mem_save_comment_0;
1195         uint32_t _ptr_location;
1196         TALLOC_CTX *_mem_save_location_0;
1197         uint32_t _ptr_devmode;
1198         TALLOC_CTX *_mem_save_devmode_0;
1199         uint32_t _ptr_sepfile;
1200         TALLOC_CTX *_mem_save_sepfile_0;
1201         uint32_t _ptr_printprocessor;
1202         TALLOC_CTX *_mem_save_printprocessor_0;
1203         uint32_t _ptr_datatype;
1204         TALLOC_CTX *_mem_save_datatype_0;
1205         uint32_t _ptr_parameters;
1206         TALLOC_CTX *_mem_save_parameters_0;
1207         uint32_t _ptr_secdesc;
1208         TALLOC_CTX *_mem_save_secdesc_0;
1209         if (ndr_flags & NDR_SCALARS) {
1210                 NDR_CHECK(ndr_pull_align(ndr, 4));
1211                 {
1212                         uint32_t _flags_save_string = ndr->flags;
1213                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1214                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1215                         if (_ptr_servername) {
1216                                 NDR_PULL_ALLOC(ndr, r->servername);
1217                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1218                         } else {
1219                                 r->servername = NULL;
1220                         }
1221                         ndr->flags = _flags_save_string;
1222                 }
1223                 {
1224                         uint32_t _flags_save_string = ndr->flags;
1225                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1226                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1227                         if (_ptr_printername) {
1228                                 NDR_PULL_ALLOC(ndr, r->printername);
1229                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1230                         } else {
1231                                 r->printername = NULL;
1232                         }
1233                         ndr->flags = _flags_save_string;
1234                 }
1235                 {
1236                         uint32_t _flags_save_string = ndr->flags;
1237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1238                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1239                         if (_ptr_sharename) {
1240                                 NDR_PULL_ALLOC(ndr, r->sharename);
1241                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1242                         } else {
1243                                 r->sharename = NULL;
1244                         }
1245                         ndr->flags = _flags_save_string;
1246                 }
1247                 {
1248                         uint32_t _flags_save_string = ndr->flags;
1249                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1250                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1251                         if (_ptr_portname) {
1252                                 NDR_PULL_ALLOC(ndr, r->portname);
1253                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1254                         } else {
1255                                 r->portname = NULL;
1256                         }
1257                         ndr->flags = _flags_save_string;
1258                 }
1259                 {
1260                         uint32_t _flags_save_string = ndr->flags;
1261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1262                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1263                         if (_ptr_drivername) {
1264                                 NDR_PULL_ALLOC(ndr, r->drivername);
1265                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1266                         } else {
1267                                 r->drivername = NULL;
1268                         }
1269                         ndr->flags = _flags_save_string;
1270                 }
1271                 {
1272                         uint32_t _flags_save_string = ndr->flags;
1273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1274                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1275                         if (_ptr_comment) {
1276                                 NDR_PULL_ALLOC(ndr, r->comment);
1277                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1278                         } else {
1279                                 r->comment = NULL;
1280                         }
1281                         ndr->flags = _flags_save_string;
1282                 }
1283                 {
1284                         uint32_t _flags_save_string = ndr->flags;
1285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1286                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1287                         if (_ptr_location) {
1288                                 NDR_PULL_ALLOC(ndr, r->location);
1289                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1290                         } else {
1291                                 r->location = NULL;
1292                         }
1293                         ndr->flags = _flags_save_string;
1294                 }
1295                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1296                 if (_ptr_devmode) {
1297                         NDR_PULL_ALLOC(ndr, r->devmode);
1298                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1299                 } else {
1300                         r->devmode = NULL;
1301                 }
1302                 {
1303                         uint32_t _flags_save_string = ndr->flags;
1304                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1305                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1306                         if (_ptr_sepfile) {
1307                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1308                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1309                         } else {
1310                                 r->sepfile = NULL;
1311                         }
1312                         ndr->flags = _flags_save_string;
1313                 }
1314                 {
1315                         uint32_t _flags_save_string = ndr->flags;
1316                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1317                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1318                         if (_ptr_printprocessor) {
1319                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1320                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1321                         } else {
1322                                 r->printprocessor = NULL;
1323                         }
1324                         ndr->flags = _flags_save_string;
1325                 }
1326                 {
1327                         uint32_t _flags_save_string = ndr->flags;
1328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1329                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1330                         if (_ptr_datatype) {
1331                                 NDR_PULL_ALLOC(ndr, r->datatype);
1332                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1333                         } else {
1334                                 r->datatype = NULL;
1335                         }
1336                         ndr->flags = _flags_save_string;
1337                 }
1338                 {
1339                         uint32_t _flags_save_string = ndr->flags;
1340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1341                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1342                         if (_ptr_parameters) {
1343                                 NDR_PULL_ALLOC(ndr, r->parameters);
1344                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1345                         } else {
1346                                 r->parameters = NULL;
1347                         }
1348                         ndr->flags = _flags_save_string;
1349                 }
1350                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1351                 if (_ptr_secdesc) {
1352                         NDR_PULL_ALLOC(ndr, r->secdesc);
1353                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1354                 } else {
1355                         r->secdesc = NULL;
1356                 }
1357                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1358                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1359                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1362                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1365         }
1366         if (ndr_flags & NDR_BUFFERS) {
1367                 {
1368                         uint32_t _flags_save_string = ndr->flags;
1369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1370                         if (r->servername) {
1371                                 uint32_t _relative_save_offset;
1372                                 _relative_save_offset = ndr->offset;
1373                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1374                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1375                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1376                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1377                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1378                                 ndr->offset = _relative_save_offset;
1379                         }
1380                         ndr->flags = _flags_save_string;
1381                 }
1382                 {
1383                         uint32_t _flags_save_string = ndr->flags;
1384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1385                         if (r->printername) {
1386                                 uint32_t _relative_save_offset;
1387                                 _relative_save_offset = ndr->offset;
1388                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1389                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1390                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1391                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1392                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1393                                 ndr->offset = _relative_save_offset;
1394                         }
1395                         ndr->flags = _flags_save_string;
1396                 }
1397                 {
1398                         uint32_t _flags_save_string = ndr->flags;
1399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1400                         if (r->sharename) {
1401                                 uint32_t _relative_save_offset;
1402                                 _relative_save_offset = ndr->offset;
1403                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1404                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1405                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1406                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1407                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1408                                 ndr->offset = _relative_save_offset;
1409                         }
1410                         ndr->flags = _flags_save_string;
1411                 }
1412                 {
1413                         uint32_t _flags_save_string = ndr->flags;
1414                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1415                         if (r->portname) {
1416                                 uint32_t _relative_save_offset;
1417                                 _relative_save_offset = ndr->offset;
1418                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1419                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1420                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1421                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1422                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1423                                 ndr->offset = _relative_save_offset;
1424                         }
1425                         ndr->flags = _flags_save_string;
1426                 }
1427                 {
1428                         uint32_t _flags_save_string = ndr->flags;
1429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1430                         if (r->drivername) {
1431                                 uint32_t _relative_save_offset;
1432                                 _relative_save_offset = ndr->offset;
1433                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1434                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1435                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1436                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1437                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1438                                 ndr->offset = _relative_save_offset;
1439                         }
1440                         ndr->flags = _flags_save_string;
1441                 }
1442                 {
1443                         uint32_t _flags_save_string = ndr->flags;
1444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1445                         if (r->comment) {
1446                                 uint32_t _relative_save_offset;
1447                                 _relative_save_offset = ndr->offset;
1448                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1449                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1450                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1451                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1452                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1453                                 ndr->offset = _relative_save_offset;
1454                         }
1455                         ndr->flags = _flags_save_string;
1456                 }
1457                 {
1458                         uint32_t _flags_save_string = ndr->flags;
1459                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1460                         if (r->location) {
1461                                 uint32_t _relative_save_offset;
1462                                 _relative_save_offset = ndr->offset;
1463                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1464                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1465                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1466                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1467                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1468                                 ndr->offset = _relative_save_offset;
1469                         }
1470                         ndr->flags = _flags_save_string;
1471                 }
1472                 if (r->devmode) {
1473                         uint32_t _relative_save_offset;
1474                         _relative_save_offset = ndr->offset;
1475                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1476                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1477                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1478                         {
1479                                 struct ndr_pull *_ndr_devmode;
1480                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1481                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1482                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1483                         }
1484                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1485                         ndr->offset = _relative_save_offset;
1486                 }
1487                 {
1488                         uint32_t _flags_save_string = ndr->flags;
1489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1490                         if (r->sepfile) {
1491                                 uint32_t _relative_save_offset;
1492                                 _relative_save_offset = ndr->offset;
1493                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1494                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1495                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1496                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1497                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1498                                 ndr->offset = _relative_save_offset;
1499                         }
1500                         ndr->flags = _flags_save_string;
1501                 }
1502                 {
1503                         uint32_t _flags_save_string = ndr->flags;
1504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1505                         if (r->printprocessor) {
1506                                 uint32_t _relative_save_offset;
1507                                 _relative_save_offset = ndr->offset;
1508                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1509                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1510                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1511                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1512                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1513                                 ndr->offset = _relative_save_offset;
1514                         }
1515                         ndr->flags = _flags_save_string;
1516                 }
1517                 {
1518                         uint32_t _flags_save_string = ndr->flags;
1519                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1520                         if (r->datatype) {
1521                                 uint32_t _relative_save_offset;
1522                                 _relative_save_offset = ndr->offset;
1523                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1524                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1525                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1526                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1527                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1528                                 ndr->offset = _relative_save_offset;
1529                         }
1530                         ndr->flags = _flags_save_string;
1531                 }
1532                 {
1533                         uint32_t _flags_save_string = ndr->flags;
1534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1535                         if (r->parameters) {
1536                                 uint32_t _relative_save_offset;
1537                                 _relative_save_offset = ndr->offset;
1538                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1539                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1540                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1541                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1542                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1543                                 ndr->offset = _relative_save_offset;
1544                         }
1545                         ndr->flags = _flags_save_string;
1546                 }
1547                 if (r->secdesc) {
1548                         uint32_t _relative_save_offset;
1549                         _relative_save_offset = ndr->offset;
1550                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1551                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1552                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1553                         {
1554                                 struct ndr_pull *_ndr_secdesc;
1555                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1556                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1557                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1558                         }
1559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1560                         ndr->offset = _relative_save_offset;
1561                 }
1562         }
1563         return NDR_ERR_SUCCESS;
1564 }
1565
1566 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1567 {
1568         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1569         ndr->depth++;
1570         ndr_print_ptr(ndr, "servername", r->servername);
1571         ndr->depth++;
1572         if (r->servername) {
1573                 ndr_print_string(ndr, "servername", r->servername);
1574         }
1575         ndr->depth--;
1576         ndr_print_ptr(ndr, "printername", r->printername);
1577         ndr->depth++;
1578         if (r->printername) {
1579                 ndr_print_string(ndr, "printername", r->printername);
1580         }
1581         ndr->depth--;
1582         ndr_print_ptr(ndr, "sharename", r->sharename);
1583         ndr->depth++;
1584         if (r->sharename) {
1585                 ndr_print_string(ndr, "sharename", r->sharename);
1586         }
1587         ndr->depth--;
1588         ndr_print_ptr(ndr, "portname", r->portname);
1589         ndr->depth++;
1590         if (r->portname) {
1591                 ndr_print_string(ndr, "portname", r->portname);
1592         }
1593         ndr->depth--;
1594         ndr_print_ptr(ndr, "drivername", r->drivername);
1595         ndr->depth++;
1596         if (r->drivername) {
1597                 ndr_print_string(ndr, "drivername", r->drivername);
1598         }
1599         ndr->depth--;
1600         ndr_print_ptr(ndr, "comment", r->comment);
1601         ndr->depth++;
1602         if (r->comment) {
1603                 ndr_print_string(ndr, "comment", r->comment);
1604         }
1605         ndr->depth--;
1606         ndr_print_ptr(ndr, "location", r->location);
1607         ndr->depth++;
1608         if (r->location) {
1609                 ndr_print_string(ndr, "location", r->location);
1610         }
1611         ndr->depth--;
1612         ndr_print_ptr(ndr, "devmode", r->devmode);
1613         ndr->depth++;
1614         if (r->devmode) {
1615                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1616         }
1617         ndr->depth--;
1618         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1619         ndr->depth++;
1620         if (r->sepfile) {
1621                 ndr_print_string(ndr, "sepfile", r->sepfile);
1622         }
1623         ndr->depth--;
1624         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1625         ndr->depth++;
1626         if (r->printprocessor) {
1627                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1628         }
1629         ndr->depth--;
1630         ndr_print_ptr(ndr, "datatype", r->datatype);
1631         ndr->depth++;
1632         if (r->datatype) {
1633                 ndr_print_string(ndr, "datatype", r->datatype);
1634         }
1635         ndr->depth--;
1636         ndr_print_ptr(ndr, "parameters", r->parameters);
1637         ndr->depth++;
1638         if (r->parameters) {
1639                 ndr_print_string(ndr, "parameters", r->parameters);
1640         }
1641         ndr->depth--;
1642         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1643         ndr->depth++;
1644         if (r->secdesc) {
1645                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1646         }
1647         ndr->depth--;
1648         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1649         ndr_print_uint32(ndr, "priority", r->priority);
1650         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1651         ndr_print_uint32(ndr, "starttime", r->starttime);
1652         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1653         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1654         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1655         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1656         ndr->depth--;
1657 }
1658
1659 static enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1660 {
1661         if (ndr_flags & NDR_SCALARS) {
1662                 NDR_CHECK(ndr_push_align(ndr, 4));
1663                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1664         }
1665         if (ndr_flags & NDR_BUFFERS) {
1666                 if (r->secdesc) {
1667                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1668                         {
1669                                 struct ndr_push *_ndr_secdesc;
1670                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1671                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1672                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1673                         }
1674                 }
1675         }
1676         return NDR_ERR_SUCCESS;
1677 }
1678
1679 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1680 {
1681         uint32_t _ptr_secdesc;
1682         TALLOC_CTX *_mem_save_secdesc_0;
1683         if (ndr_flags & NDR_SCALARS) {
1684                 NDR_CHECK(ndr_pull_align(ndr, 4));
1685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1686                 if (_ptr_secdesc) {
1687                         NDR_PULL_ALLOC(ndr, r->secdesc);
1688                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1689                 } else {
1690                         r->secdesc = NULL;
1691                 }
1692         }
1693         if (ndr_flags & NDR_BUFFERS) {
1694                 if (r->secdesc) {
1695                         uint32_t _relative_save_offset;
1696                         _relative_save_offset = ndr->offset;
1697                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1698                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1699                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1700                         {
1701                                 struct ndr_pull *_ndr_secdesc;
1702                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1703                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1704                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1705                         }
1706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1707                         ndr->offset = _relative_save_offset;
1708                 }
1709         }
1710         return NDR_ERR_SUCCESS;
1711 }
1712
1713 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1714 {
1715         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1716         ndr->depth++;
1717         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1718         ndr->depth++;
1719         if (r->secdesc) {
1720                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1721         }
1722         ndr->depth--;
1723         ndr->depth--;
1724 }
1725
1726 static enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1727 {
1728         if (ndr_flags & NDR_SCALARS) {
1729                 NDR_CHECK(ndr_push_align(ndr, 4));
1730                 {
1731                         uint32_t _flags_save_string = ndr->flags;
1732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1733                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1734                         ndr->flags = _flags_save_string;
1735                 }
1736                 {
1737                         uint32_t _flags_save_string = ndr->flags;
1738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1739                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1740                         ndr->flags = _flags_save_string;
1741                 }
1742                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1743         }
1744         if (ndr_flags & NDR_BUFFERS) {
1745                 {
1746                         uint32_t _flags_save_string = ndr->flags;
1747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1748                         if (r->printername) {
1749                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1750                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1751                         }
1752                         ndr->flags = _flags_save_string;
1753                 }
1754                 {
1755                         uint32_t _flags_save_string = ndr->flags;
1756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1757                         if (r->servername) {
1758                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1759                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1760                         }
1761                         ndr->flags = _flags_save_string;
1762                 }
1763         }
1764         return NDR_ERR_SUCCESS;
1765 }
1766
1767 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1768 {
1769         uint32_t _ptr_printername;
1770         TALLOC_CTX *_mem_save_printername_0;
1771         uint32_t _ptr_servername;
1772         TALLOC_CTX *_mem_save_servername_0;
1773         if (ndr_flags & NDR_SCALARS) {
1774                 NDR_CHECK(ndr_pull_align(ndr, 4));
1775                 {
1776                         uint32_t _flags_save_string = ndr->flags;
1777                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1778                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1779                         if (_ptr_printername) {
1780                                 NDR_PULL_ALLOC(ndr, r->printername);
1781                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1782                         } else {
1783                                 r->printername = NULL;
1784                         }
1785                         ndr->flags = _flags_save_string;
1786                 }
1787                 {
1788                         uint32_t _flags_save_string = ndr->flags;
1789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1791                         if (_ptr_servername) {
1792                                 NDR_PULL_ALLOC(ndr, r->servername);
1793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1794                         } else {
1795                                 r->servername = NULL;
1796                         }
1797                         ndr->flags = _flags_save_string;
1798                 }
1799                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1800         }
1801         if (ndr_flags & NDR_BUFFERS) {
1802                 {
1803                         uint32_t _flags_save_string = ndr->flags;
1804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1805                         if (r->printername) {
1806                                 uint32_t _relative_save_offset;
1807                                 _relative_save_offset = ndr->offset;
1808                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1809                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1810                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1811                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1812                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1813                                 ndr->offset = _relative_save_offset;
1814                         }
1815                         ndr->flags = _flags_save_string;
1816                 }
1817                 {
1818                         uint32_t _flags_save_string = ndr->flags;
1819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1820                         if (r->servername) {
1821                                 uint32_t _relative_save_offset;
1822                                 _relative_save_offset = ndr->offset;
1823                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1824                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1825                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1826                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1827                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1828                                 ndr->offset = _relative_save_offset;
1829                         }
1830                         ndr->flags = _flags_save_string;
1831                 }
1832         }
1833         return NDR_ERR_SUCCESS;
1834 }
1835
1836 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1837 {
1838         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1839         ndr->depth++;
1840         ndr_print_ptr(ndr, "printername", r->printername);
1841         ndr->depth++;
1842         if (r->printername) {
1843                 ndr_print_string(ndr, "printername", r->printername);
1844         }
1845         ndr->depth--;
1846         ndr_print_ptr(ndr, "servername", r->servername);
1847         ndr->depth++;
1848         if (r->servername) {
1849                 ndr_print_string(ndr, "servername", r->servername);
1850         }
1851         ndr->depth--;
1852         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1853         ndr->depth--;
1854 }
1855
1856 static enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1857 {
1858         if (ndr_flags & NDR_SCALARS) {
1859                 NDR_CHECK(ndr_push_align(ndr, 4));
1860                 {
1861                         uint32_t _flags_save_string = ndr->flags;
1862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1863                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1864                         ndr->flags = _flags_save_string;
1865                 }
1866                 {
1867                         uint32_t _flags_save_string = ndr->flags;
1868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1869                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1870                         ndr->flags = _flags_save_string;
1871                 }
1872                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1875         }
1876         if (ndr_flags & NDR_BUFFERS) {
1877                 {
1878                         uint32_t _flags_save_string = ndr->flags;
1879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1880                         if (r->printername) {
1881                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1882                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1883                         }
1884                         ndr->flags = _flags_save_string;
1885                 }
1886                 {
1887                         uint32_t _flags_save_string = ndr->flags;
1888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1889                         if (r->portname) {
1890                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1891                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1892                         }
1893                         ndr->flags = _flags_save_string;
1894                 }
1895         }
1896         return NDR_ERR_SUCCESS;
1897 }
1898
1899 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1900 {
1901         uint32_t _ptr_printername;
1902         TALLOC_CTX *_mem_save_printername_0;
1903         uint32_t _ptr_portname;
1904         TALLOC_CTX *_mem_save_portname_0;
1905         if (ndr_flags & NDR_SCALARS) {
1906                 NDR_CHECK(ndr_pull_align(ndr, 4));
1907                 {
1908                         uint32_t _flags_save_string = ndr->flags;
1909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1911                         if (_ptr_printername) {
1912                                 NDR_PULL_ALLOC(ndr, r->printername);
1913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1914                         } else {
1915                                 r->printername = NULL;
1916                         }
1917                         ndr->flags = _flags_save_string;
1918                 }
1919                 {
1920                         uint32_t _flags_save_string = ndr->flags;
1921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1922                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1923                         if (_ptr_portname) {
1924                                 NDR_PULL_ALLOC(ndr, r->portname);
1925                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1926                         } else {
1927                                 r->portname = NULL;
1928                         }
1929                         ndr->flags = _flags_save_string;
1930                 }
1931                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1934         }
1935         if (ndr_flags & NDR_BUFFERS) {
1936                 {
1937                         uint32_t _flags_save_string = ndr->flags;
1938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1939                         if (r->printername) {
1940                                 uint32_t _relative_save_offset;
1941                                 _relative_save_offset = ndr->offset;
1942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1943                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1944                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1947                                 ndr->offset = _relative_save_offset;
1948                         }
1949                         ndr->flags = _flags_save_string;
1950                 }
1951                 {
1952                         uint32_t _flags_save_string = ndr->flags;
1953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1954                         if (r->portname) {
1955                                 uint32_t _relative_save_offset;
1956                                 _relative_save_offset = ndr->offset;
1957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1958                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1959                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1962                                 ndr->offset = _relative_save_offset;
1963                         }
1964                         ndr->flags = _flags_save_string;
1965                 }
1966         }
1967         return NDR_ERR_SUCCESS;
1968 }
1969
1970 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1971 {
1972         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
1973         ndr->depth++;
1974         ndr_print_ptr(ndr, "printername", r->printername);
1975         ndr->depth++;
1976         if (r->printername) {
1977                 ndr_print_string(ndr, "printername", r->printername);
1978         }
1979         ndr->depth--;
1980         ndr_print_ptr(ndr, "portname", r->portname);
1981         ndr->depth++;
1982         if (r->portname) {
1983                 ndr_print_string(ndr, "portname", r->portname);
1984         }
1985         ndr->depth--;
1986         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1987         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
1988         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
1989         ndr->depth--;
1990 }
1991
1992 static enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
1993 {
1994         if (ndr_flags & NDR_SCALARS) {
1995                 NDR_CHECK(ndr_push_align(ndr, 4));
1996                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1997         }
1998         if (ndr_flags & NDR_BUFFERS) {
1999         }
2000         return NDR_ERR_SUCCESS;
2001 }
2002
2003 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2004 {
2005         if (ndr_flags & NDR_SCALARS) {
2006                 NDR_CHECK(ndr_pull_align(ndr, 4));
2007                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2008         }
2009         if (ndr_flags & NDR_BUFFERS) {
2010         }
2011         return NDR_ERR_SUCCESS;
2012 }
2013
2014 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2015 {
2016         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2017         ndr->depth++;
2018         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2019         ndr->depth--;
2020 }
2021
2022 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2023 {
2024         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2025         return NDR_ERR_SUCCESS;
2026 }
2027
2028 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2029 {
2030         uint32_t v;
2031         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2032         *r = v;
2033         return NDR_ERR_SUCCESS;
2034 }
2035
2036 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2037 {
2038         ndr_print_uint32(ndr, name, r);
2039         ndr->depth++;
2040         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2041         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2042         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2043         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2044         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2045         ndr->depth--;
2046 }
2047
2048 static enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2049 {
2050         if (ndr_flags & NDR_SCALARS) {
2051                 NDR_CHECK(ndr_push_align(ndr, 4));
2052                 {
2053                         uint32_t _flags_save_string = ndr->flags;
2054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2055                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2056                         ndr->flags = _flags_save_string;
2057                 }
2058                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2059         }
2060         if (ndr_flags & NDR_BUFFERS) {
2061                 {
2062                         uint32_t _flags_save_string = ndr->flags;
2063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2064                         if (r->guid) {
2065                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2067                         }
2068                         ndr->flags = _flags_save_string;
2069                 }
2070         }
2071         return NDR_ERR_SUCCESS;
2072 }
2073
2074 static enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2075 {
2076         uint32_t _ptr_guid;
2077         TALLOC_CTX *_mem_save_guid_0;
2078         if (ndr_flags & NDR_SCALARS) {
2079                 NDR_CHECK(ndr_pull_align(ndr, 4));
2080                 {
2081                         uint32_t _flags_save_string = ndr->flags;
2082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2083                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2084                         if (_ptr_guid) {
2085                                 NDR_PULL_ALLOC(ndr, r->guid);
2086                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2087                         } else {
2088                                 r->guid = NULL;
2089                         }
2090                         ndr->flags = _flags_save_string;
2091                 }
2092                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2093         }
2094         if (ndr_flags & NDR_BUFFERS) {
2095                 {
2096                         uint32_t _flags_save_string = ndr->flags;
2097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2098                         if (r->guid) {
2099                                 uint32_t _relative_save_offset;
2100                                 _relative_save_offset = ndr->offset;
2101                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2102                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2103                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2104                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2105                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2106                                 ndr->offset = _relative_save_offset;
2107                         }
2108                         ndr->flags = _flags_save_string;
2109                 }
2110         }
2111         return NDR_ERR_SUCCESS;
2112 }
2113
2114 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2115 {
2116         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2117         ndr->depth++;
2118         ndr_print_ptr(ndr, "guid", r->guid);
2119         ndr->depth++;
2120         if (r->guid) {
2121                 ndr_print_string(ndr, "guid", r->guid);
2122         }
2123         ndr->depth--;
2124         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2125         ndr->depth--;
2126 }
2127
2128 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2129 {
2130         if (ndr_flags & NDR_SCALARS) {
2131                 NDR_CHECK(ndr_push_align(ndr, 4));
2132                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2133         }
2134         if (ndr_flags & NDR_BUFFERS) {
2135                 if (r->devmode) {
2136                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2137                         {
2138                                 struct ndr_push *_ndr_devmode;
2139                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2140                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2141                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2142                         }
2143                 }
2144         }
2145         return NDR_ERR_SUCCESS;
2146 }
2147
2148 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2149 {
2150         uint32_t _ptr_devmode;
2151         TALLOC_CTX *_mem_save_devmode_0;
2152         if (ndr_flags & NDR_SCALARS) {
2153                 NDR_CHECK(ndr_pull_align(ndr, 4));
2154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2155                 if (_ptr_devmode) {
2156                         NDR_PULL_ALLOC(ndr, r->devmode);
2157                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2158                 } else {
2159                         r->devmode = NULL;
2160                 }
2161         }
2162         if (ndr_flags & NDR_BUFFERS) {
2163                 if (r->devmode) {
2164                         uint32_t _relative_save_offset;
2165                         _relative_save_offset = ndr->offset;
2166                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2167                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2168                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2169                         {
2170                                 struct ndr_pull *_ndr_devmode;
2171                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2172                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2173                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2174                         }
2175                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2176                         ndr->offset = _relative_save_offset;
2177                 }
2178         }
2179         return NDR_ERR_SUCCESS;
2180 }
2181
2182 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2183 {
2184         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2185         ndr->depth++;
2186         ndr_print_ptr(ndr, "devmode", r->devmode);
2187         ndr->depth++;
2188         if (r->devmode) {
2189                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2190         }
2191         ndr->depth--;
2192         ndr->depth--;
2193 }
2194
2195 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2196 {
2197         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2198         if (ndr_flags & NDR_SCALARS) {
2199                 int level = ndr_push_get_switch_value(ndr, r);
2200                 switch (level) {
2201                         case 0: {
2202                                 NDR_CHECK(ndr_push_align(ndr, 4));
2203                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2204                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2205                         break; }
2206
2207                         case 1: {
2208                                 NDR_CHECK(ndr_push_align(ndr, 4));
2209                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2210                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2211                         break; }
2212
2213                         case 2: {
2214                                 NDR_CHECK(ndr_push_align(ndr, 4));
2215                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2216                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2217                         break; }
2218
2219                         case 3: {
2220                                 NDR_CHECK(ndr_push_align(ndr, 4));
2221                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2222                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2223                         break; }
2224
2225                         case 4: {
2226                                 NDR_CHECK(ndr_push_align(ndr, 4));
2227                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2228                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2229                         break; }
2230
2231                         case 5: {
2232                                 NDR_CHECK(ndr_push_align(ndr, 4));
2233                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2234                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2235                         break; }
2236
2237                         case 6: {
2238                                 NDR_CHECK(ndr_push_align(ndr, 4));
2239                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2240                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2241                         break; }
2242
2243                         case 7: {
2244                                 NDR_CHECK(ndr_push_align(ndr, 4));
2245                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2246                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2247                         break; }
2248
2249                         case 8: {
2250                                 NDR_CHECK(ndr_push_align(ndr, 4));
2251                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2252                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2253                         break; }
2254
2255                         case 9: {
2256                                 NDR_CHECK(ndr_push_align(ndr, 4));
2257                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2258                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2259                         break; }
2260
2261                         default: {
2262                         break; }
2263
2264                 }
2265         }
2266         if (ndr_flags & NDR_BUFFERS) {
2267                 int level = ndr_push_get_switch_value(ndr, r);
2268                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2269                 switch (level) {
2270                         case 0:
2271                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2272                         break;
2273
2274                         case 1:
2275                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2276                         break;
2277
2278                         case 2:
2279                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2280                         break;
2281
2282                         case 3:
2283                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2284                         break;
2285
2286                         case 4:
2287                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2288                         break;
2289
2290                         case 5:
2291                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2292                         break;
2293
2294                         case 6:
2295                         break;
2296
2297                         case 7:
2298                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2299                         break;
2300
2301                         case 8:
2302                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2303                         break;
2304
2305                         case 9:
2306                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2307                         break;
2308
2309                         default:
2310                         break;
2311
2312                 }
2313         }
2314         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2315         return NDR_ERR_SUCCESS;
2316 }
2317
2318 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2319 {
2320         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2321         int level;
2322         level = ndr_pull_get_switch_value(ndr, r);
2323         if (ndr_flags & NDR_SCALARS) {
2324                 switch (level) {
2325                         case 0: {
2326                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2327                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2328                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2329                         break; }
2330
2331                         case 1: {
2332                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2333                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2334                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2335                         break; }
2336
2337                         case 2: {
2338                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2339                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2340                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2341                         break; }
2342
2343                         case 3: {
2344                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2345                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2346                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2347                         break; }
2348
2349                         case 4: {
2350                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2351                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2352                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2353                         break; }
2354
2355                         case 5: {
2356                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2357                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2358                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2359                         break; }
2360
2361                         case 6: {
2362                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2363                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2364                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2365                         break; }
2366
2367                         case 7: {
2368                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2369                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2370                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2371                         break; }
2372
2373                         case 8: {
2374                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2375                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2376                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2377                         break; }
2378
2379                         case 9: {
2380                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2381                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2382                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2383                         break; }
2384
2385                         default: {
2386                         break; }
2387
2388                 }
2389         }
2390         if (ndr_flags & NDR_BUFFERS) {
2391                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2392                 switch (level) {
2393                         case 0:
2394                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2395                         break;
2396
2397                         case 1:
2398                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2399                         break;
2400
2401                         case 2:
2402                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2403                         break;
2404
2405                         case 3:
2406                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2407                         break;
2408
2409                         case 4:
2410                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2411                         break;
2412
2413                         case 5:
2414                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2415                         break;
2416
2417                         case 6:
2418                         break;
2419
2420                         case 7:
2421                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2422                         break;
2423
2424                         case 8:
2425                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2426                         break;
2427
2428                         case 9:
2429                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2430                         break;
2431
2432                         default:
2433                         break;
2434
2435                 }
2436         }
2437         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2438         return NDR_ERR_SUCCESS;
2439 }
2440
2441 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2442 {
2443         int level;
2444         level = ndr_print_get_switch_value(ndr, r);
2445         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2446         switch (level) {
2447                 case 0:
2448                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2449                 break;
2450
2451                 case 1:
2452                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2453                 break;
2454
2455                 case 2:
2456                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2457                 break;
2458
2459                 case 3:
2460                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2461                 break;
2462
2463                 case 4:
2464                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2465                 break;
2466
2467                 case 5:
2468                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2469                 break;
2470
2471                 case 6:
2472                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2473                 break;
2474
2475                 case 7:
2476                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2477                 break;
2478
2479                 case 8:
2480                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2481                 break;
2482
2483                 case 9:
2484                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2485                 break;
2486
2487                 default:
2488                 break;
2489
2490         }
2491 }
2492
2493 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2494 {
2495         if (ndr_flags & NDR_SCALARS) {
2496                 NDR_CHECK(ndr_push_align(ndr, 4));
2497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2498                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2499         }
2500         if (ndr_flags & NDR_BUFFERS) {
2501                 if (r->devmode) {
2502                         {
2503                                 struct ndr_push *_ndr_devmode;
2504                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2505                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2506                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2507                         }
2508                 }
2509         }
2510         return NDR_ERR_SUCCESS;
2511 }
2512
2513 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2514 {
2515         uint32_t _ptr_devmode;
2516         TALLOC_CTX *_mem_save_devmode_0;
2517         if (ndr_flags & NDR_SCALARS) {
2518                 NDR_CHECK(ndr_pull_align(ndr, 4));
2519                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2521                 if (_ptr_devmode) {
2522                         NDR_PULL_ALLOC(ndr, r->devmode);
2523                 } else {
2524                         r->devmode = NULL;
2525                 }
2526         }
2527         if (ndr_flags & NDR_BUFFERS) {
2528                 if (r->devmode) {
2529                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2530                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2531                         {
2532                                 struct ndr_pull *_ndr_devmode;
2533                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2534                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2535                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2536                         }
2537                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2538                 }
2539         }
2540         return NDR_ERR_SUCCESS;
2541 }
2542
2543 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2544 {
2545         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2546         ndr->depth++;
2547         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2548         ndr_print_ptr(ndr, "devmode", r->devmode);
2549         ndr->depth++;
2550         if (r->devmode) {
2551                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2552         }
2553         ndr->depth--;
2554         ndr->depth--;
2555 }
2556
2557 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2558 {
2559         if (ndr_flags & NDR_SCALARS) {
2560                 NDR_CHECK(ndr_push_align(ndr, 4));
2561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2562                 {
2563                         uint32_t _flags_save_string = ndr->flags;
2564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2566                         ndr->flags = _flags_save_string;
2567                 }
2568                 {
2569                         uint32_t _flags_save_string = ndr->flags;
2570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2572                         ndr->flags = _flags_save_string;
2573                 }
2574                 {
2575                         uint32_t _flags_save_string = ndr->flags;
2576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2578                         ndr->flags = _flags_save_string;
2579                 }
2580                 {
2581                         uint32_t _flags_save_string = ndr->flags;
2582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2584                         ndr->flags = _flags_save_string;
2585                 }
2586                 {
2587                         uint32_t _flags_save_string = ndr->flags;
2588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2590                         ndr->flags = _flags_save_string;
2591                 }
2592                 {
2593                         uint32_t _flags_save_string = ndr->flags;
2594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2595                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2596                         ndr->flags = _flags_save_string;
2597                 }
2598                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2603                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2604         }
2605         if (ndr_flags & NDR_BUFFERS) {
2606                 {
2607                         uint32_t _flags_save_string = ndr->flags;
2608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2609                         if (r->printer_name) {
2610                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2611                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2612                         }
2613                         ndr->flags = _flags_save_string;
2614                 }
2615                 {
2616                         uint32_t _flags_save_string = ndr->flags;
2617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2618                         if (r->server_name) {
2619                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2620                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2621                         }
2622                         ndr->flags = _flags_save_string;
2623                 }
2624                 {
2625                         uint32_t _flags_save_string = ndr->flags;
2626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2627                         if (r->user_name) {
2628                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2629                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2630                         }
2631                         ndr->flags = _flags_save_string;
2632                 }
2633                 {
2634                         uint32_t _flags_save_string = ndr->flags;
2635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2636                         if (r->document_name) {
2637                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2638                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2639                         }
2640                         ndr->flags = _flags_save_string;
2641                 }
2642                 {
2643                         uint32_t _flags_save_string = ndr->flags;
2644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2645                         if (r->data_type) {
2646                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2647                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2648                         }
2649                         ndr->flags = _flags_save_string;
2650                 }
2651                 {
2652                         uint32_t _flags_save_string = ndr->flags;
2653                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2654                         if (r->text_status) {
2655                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2656                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2657                         }
2658                         ndr->flags = _flags_save_string;
2659                 }
2660         }
2661         return NDR_ERR_SUCCESS;
2662 }
2663
2664 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2665 {
2666         uint32_t _ptr_printer_name;
2667         TALLOC_CTX *_mem_save_printer_name_0;
2668         uint32_t _ptr_server_name;
2669         TALLOC_CTX *_mem_save_server_name_0;
2670         uint32_t _ptr_user_name;
2671         TALLOC_CTX *_mem_save_user_name_0;
2672         uint32_t _ptr_document_name;
2673         TALLOC_CTX *_mem_save_document_name_0;
2674         uint32_t _ptr_data_type;
2675         TALLOC_CTX *_mem_save_data_type_0;
2676         uint32_t _ptr_text_status;
2677         TALLOC_CTX *_mem_save_text_status_0;
2678         if (ndr_flags & NDR_SCALARS) {
2679                 NDR_CHECK(ndr_pull_align(ndr, 4));
2680                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2685                         if (_ptr_printer_name) {
2686                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2687                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2688                         } else {
2689                                 r->printer_name = NULL;
2690                         }
2691                         ndr->flags = _flags_save_string;
2692                 }
2693                 {
2694                         uint32_t _flags_save_string = ndr->flags;
2695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2696                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2697                         if (_ptr_server_name) {
2698                                 NDR_PULL_ALLOC(ndr, r->server_name);
2699                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2700                         } else {
2701                                 r->server_name = NULL;
2702                         }
2703                         ndr->flags = _flags_save_string;
2704                 }
2705                 {
2706                         uint32_t _flags_save_string = ndr->flags;
2707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2708                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2709                         if (_ptr_user_name) {
2710                                 NDR_PULL_ALLOC(ndr, r->user_name);
2711                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2712                         } else {
2713                                 r->user_name = NULL;
2714                         }
2715                         ndr->flags = _flags_save_string;
2716                 }
2717                 {
2718                         uint32_t _flags_save_string = ndr->flags;
2719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2720                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2721                         if (_ptr_document_name) {
2722                                 NDR_PULL_ALLOC(ndr, r->document_name);
2723                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2724                         } else {
2725                                 r->document_name = NULL;
2726                         }
2727                         ndr->flags = _flags_save_string;
2728                 }
2729                 {
2730                         uint32_t _flags_save_string = ndr->flags;
2731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2732                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2733                         if (_ptr_data_type) {
2734                                 NDR_PULL_ALLOC(ndr, r->data_type);
2735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2736                         } else {
2737                                 r->data_type = NULL;
2738                         }
2739                         ndr->flags = _flags_save_string;
2740                 }
2741                 {
2742                         uint32_t _flags_save_string = ndr->flags;
2743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2745                         if (_ptr_text_status) {
2746                                 NDR_PULL_ALLOC(ndr, r->text_status);
2747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2748                         } else {
2749                                 r->text_status = NULL;
2750                         }
2751                         ndr->flags = _flags_save_string;
2752                 }
2753                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2754                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2756                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2757                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2758                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2759         }
2760         if (ndr_flags & NDR_BUFFERS) {
2761                 {
2762                         uint32_t _flags_save_string = ndr->flags;
2763                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2764                         if (r->printer_name) {
2765                                 uint32_t _relative_save_offset;
2766                                 _relative_save_offset = ndr->offset;
2767                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2768                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2769                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2770                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2771                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2772                                 ndr->offset = _relative_save_offset;
2773                         }
2774                         ndr->flags = _flags_save_string;
2775                 }
2776                 {
2777                         uint32_t _flags_save_string = ndr->flags;
2778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2779                         if (r->server_name) {
2780                                 uint32_t _relative_save_offset;
2781                                 _relative_save_offset = ndr->offset;
2782                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2783                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2784                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2785                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2786                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2787                                 ndr->offset = _relative_save_offset;
2788                         }
2789                         ndr->flags = _flags_save_string;
2790                 }
2791                 {
2792                         uint32_t _flags_save_string = ndr->flags;
2793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2794                         if (r->user_name) {
2795                                 uint32_t _relative_save_offset;
2796                                 _relative_save_offset = ndr->offset;
2797                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2798                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2799                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2800                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2801                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2802                                 ndr->offset = _relative_save_offset;
2803                         }
2804                         ndr->flags = _flags_save_string;
2805                 }
2806                 {
2807                         uint32_t _flags_save_string = ndr->flags;
2808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2809                         if (r->document_name) {
2810                                 uint32_t _relative_save_offset;
2811                                 _relative_save_offset = ndr->offset;
2812                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2813                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2814                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2815                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2816                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2817                                 ndr->offset = _relative_save_offset;
2818                         }
2819                         ndr->flags = _flags_save_string;
2820                 }
2821                 {
2822                         uint32_t _flags_save_string = ndr->flags;
2823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2824                         if (r->data_type) {
2825                                 uint32_t _relative_save_offset;
2826                                 _relative_save_offset = ndr->offset;
2827                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2828                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2829                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2830                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2831                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2832                                 ndr->offset = _relative_save_offset;
2833                         }
2834                         ndr->flags = _flags_save_string;
2835                 }
2836                 {
2837                         uint32_t _flags_save_string = ndr->flags;
2838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2839                         if (r->text_status) {
2840                                 uint32_t _relative_save_offset;
2841                                 _relative_save_offset = ndr->offset;
2842                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2843                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2844                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2845                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2846                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2847                                 ndr->offset = _relative_save_offset;
2848                         }
2849                         ndr->flags = _flags_save_string;
2850                 }
2851         }
2852         return NDR_ERR_SUCCESS;
2853 }
2854
2855 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2856 {
2857         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2858         ndr->depth++;
2859         ndr_print_uint32(ndr, "job_id", r->job_id);
2860         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2861         ndr->depth++;
2862         if (r->printer_name) {
2863                 ndr_print_string(ndr, "printer_name", r->printer_name);
2864         }
2865         ndr->depth--;
2866         ndr_print_ptr(ndr, "server_name", r->server_name);
2867         ndr->depth++;
2868         if (r->server_name) {
2869                 ndr_print_string(ndr, "server_name", r->server_name);
2870         }
2871         ndr->depth--;
2872         ndr_print_ptr(ndr, "user_name", r->user_name);
2873         ndr->depth++;
2874         if (r->user_name) {
2875                 ndr_print_string(ndr, "user_name", r->user_name);
2876         }
2877         ndr->depth--;
2878         ndr_print_ptr(ndr, "document_name", r->document_name);
2879         ndr->depth++;
2880         if (r->document_name) {
2881                 ndr_print_string(ndr, "document_name", r->document_name);
2882         }
2883         ndr->depth--;
2884         ndr_print_ptr(ndr, "data_type", r->data_type);
2885         ndr->depth++;
2886         if (r->data_type) {
2887                 ndr_print_string(ndr, "data_type", r->data_type);
2888         }
2889         ndr->depth--;
2890         ndr_print_ptr(ndr, "text_status", r->text_status);
2891         ndr->depth++;
2892         if (r->text_status) {
2893                 ndr_print_string(ndr, "text_status", r->text_status);
2894         }
2895         ndr->depth--;
2896         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2897         ndr_print_uint32(ndr, "priority", r->priority);
2898         ndr_print_uint32(ndr, "position", r->position);
2899         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2900         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2901         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2902         ndr->depth--;
2903 }
2904
2905 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
2906 {
2907         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
2908 }
2909
2910 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2911 {
2912         if (ndr_flags & NDR_SCALARS) {
2913                 NDR_CHECK(ndr_push_align(ndr, 4));
2914                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2915                 {
2916                         uint32_t _flags_save_string = ndr->flags;
2917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2918                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2919                         ndr->flags = _flags_save_string;
2920                 }
2921                 {
2922                         uint32_t _flags_save_string = ndr->flags;
2923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2924                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2925                         ndr->flags = _flags_save_string;
2926                 }
2927                 {
2928                         uint32_t _flags_save_string = ndr->flags;
2929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2930                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2931                         ndr->flags = _flags_save_string;
2932                 }
2933                 {
2934                         uint32_t _flags_save_string = ndr->flags;
2935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2936                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2937                         ndr->flags = _flags_save_string;
2938                 }
2939                 {
2940                         uint32_t _flags_save_string = ndr->flags;
2941                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2942                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2943                         ndr->flags = _flags_save_string;
2944                 }
2945                 {
2946                         uint32_t _flags_save_string = ndr->flags;
2947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2948                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2949                         ndr->flags = _flags_save_string;
2950                 }
2951                 {
2952                         uint32_t _flags_save_string = ndr->flags;
2953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2954                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
2955                         ndr->flags = _flags_save_string;
2956                 }
2957                 {
2958                         uint32_t _flags_save_string = ndr->flags;
2959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2960                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
2961                         ndr->flags = _flags_save_string;
2962                 }
2963                 {
2964                         uint32_t _flags_save_string = ndr->flags;
2965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2966                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
2967                         ndr->flags = _flags_save_string;
2968                 }
2969                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2970                 {
2971                         uint32_t _flags_save_string = ndr->flags;
2972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2973                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2974                         ndr->flags = _flags_save_string;
2975                 }
2976                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
2977                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2978                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
2981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
2982                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
2984                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
2986                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2987         }
2988         if (ndr_flags & NDR_BUFFERS) {
2989                 {
2990                         uint32_t _flags_save_string = ndr->flags;
2991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2992                         if (r->printer_name) {
2993                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2994                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2995                         }
2996                         ndr->flags = _flags_save_string;
2997                 }
2998                 {
2999                         uint32_t _flags_save_string = ndr->flags;
3000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3001                         if (r->server_name) {
3002                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3003                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3004                         }
3005                         ndr->flags = _flags_save_string;
3006                 }
3007                 {
3008                         uint32_t _flags_save_string = ndr->flags;
3009                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3010                         if (r->user_name) {
3011                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3012                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3013                         }
3014                         ndr->flags = _flags_save_string;
3015                 }
3016                 {
3017                         uint32_t _flags_save_string = ndr->flags;
3018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3019                         if (r->document_name) {
3020                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3021                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3022                         }
3023                         ndr->flags = _flags_save_string;
3024                 }
3025                 {
3026                         uint32_t _flags_save_string = ndr->flags;
3027                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3028                         if (r->notify_name) {
3029                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3030                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3031                         }
3032                         ndr->flags = _flags_save_string;
3033                 }
3034                 {
3035                         uint32_t _flags_save_string = ndr->flags;
3036                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3037                         if (r->data_type) {
3038                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3039                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3040                         }
3041                         ndr->flags = _flags_save_string;
3042                 }
3043                 {
3044                         uint32_t _flags_save_string = ndr->flags;
3045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3046                         if (r->print_processor) {
3047                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3048                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3049                         }
3050                         ndr->flags = _flags_save_string;
3051                 }
3052                 {
3053                         uint32_t _flags_save_string = ndr->flags;
3054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3055                         if (r->parameters) {
3056                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3057                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3058                         }
3059                         ndr->flags = _flags_save_string;
3060                 }
3061                 {
3062                         uint32_t _flags_save_string = ndr->flags;
3063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3064                         if (r->driver_name) {
3065                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3066                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3067                         }
3068                         ndr->flags = _flags_save_string;
3069                 }
3070                 if (r->devmode) {
3071                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3072                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3073                 }
3074                 {
3075                         uint32_t _flags_save_string = ndr->flags;
3076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3077                         if (r->text_status) {
3078                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3079                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3080                         }
3081                         ndr->flags = _flags_save_string;
3082                 }
3083                 if (r->secdesc) {
3084                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3085                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3086                 }
3087         }
3088         return NDR_ERR_SUCCESS;
3089 }
3090
3091 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3092 {
3093         uint32_t _ptr_printer_name;
3094         TALLOC_CTX *_mem_save_printer_name_0;
3095         uint32_t _ptr_server_name;
3096         TALLOC_CTX *_mem_save_server_name_0;
3097         uint32_t _ptr_user_name;
3098         TALLOC_CTX *_mem_save_user_name_0;
3099         uint32_t _ptr_document_name;
3100         TALLOC_CTX *_mem_save_document_name_0;
3101         uint32_t _ptr_notify_name;
3102         TALLOC_CTX *_mem_save_notify_name_0;
3103         uint32_t _ptr_data_type;
3104         TALLOC_CTX *_mem_save_data_type_0;
3105         uint32_t _ptr_print_processor;
3106         TALLOC_CTX *_mem_save_print_processor_0;
3107         uint32_t _ptr_parameters;
3108         TALLOC_CTX *_mem_save_parameters_0;
3109         uint32_t _ptr_driver_name;
3110         TALLOC_CTX *_mem_save_driver_name_0;
3111         uint32_t _ptr_devmode;
3112         TALLOC_CTX *_mem_save_devmode_0;
3113         uint32_t _ptr_text_status;
3114         TALLOC_CTX *_mem_save_text_status_0;
3115         uint32_t _ptr_secdesc;
3116         TALLOC_CTX *_mem_save_secdesc_0;
3117         if (ndr_flags & NDR_SCALARS) {
3118                 NDR_CHECK(ndr_pull_align(ndr, 4));
3119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3120                 {
3121                         uint32_t _flags_save_string = ndr->flags;
3122                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3123                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3124                         if (_ptr_printer_name) {
3125                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3126                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3127                         } else {
3128                                 r->printer_name = NULL;
3129                         }
3130                         ndr->flags = _flags_save_string;
3131                 }
3132                 {
3133                         uint32_t _flags_save_string = ndr->flags;
3134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3135                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3136                         if (_ptr_server_name) {
3137                                 NDR_PULL_ALLOC(ndr, r->server_name);
3138                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3139                         } else {
3140                                 r->server_name = NULL;
3141                         }
3142                         ndr->flags = _flags_save_string;
3143                 }
3144                 {
3145                         uint32_t _flags_save_string = ndr->flags;
3146                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3147                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3148                         if (_ptr_user_name) {
3149                                 NDR_PULL_ALLOC(ndr, r->user_name);
3150                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3151                         } else {
3152                                 r->user_name = NULL;
3153                         }
3154                         ndr->flags = _flags_save_string;
3155                 }
3156                 {
3157                         uint32_t _flags_save_string = ndr->flags;
3158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3159                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3160                         if (_ptr_document_name) {
3161                                 NDR_PULL_ALLOC(ndr, r->document_name);
3162                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3163                         } else {
3164                                 r->document_name = NULL;
3165                         }
3166                         ndr->flags = _flags_save_string;
3167                 }
3168                 {
3169                         uint32_t _flags_save_string = ndr->flags;
3170                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3171                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3172                         if (_ptr_notify_name) {
3173                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3174                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3175                         } else {
3176                                 r->notify_name = NULL;
3177                         }
3178                         ndr->flags = _flags_save_string;
3179                 }
3180                 {
3181                         uint32_t _flags_save_string = ndr->flags;
3182                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3183                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3184                         if (_ptr_data_type) {
3185                                 NDR_PULL_ALLOC(ndr, r->data_type);
3186                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3187                         } else {
3188                                 r->data_type = NULL;
3189                         }
3190                         ndr->flags = _flags_save_string;
3191                 }
3192                 {
3193                         uint32_t _flags_save_string = ndr->flags;
3194                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3195                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3196                         if (_ptr_print_processor) {
3197                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3198                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3199                         } else {
3200                                 r->print_processor = NULL;
3201                         }
3202                         ndr->flags = _flags_save_string;
3203                 }
3204                 {
3205                         uint32_t _flags_save_string = ndr->flags;
3206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3207                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3208                         if (_ptr_parameters) {
3209                                 NDR_PULL_ALLOC(ndr, r->parameters);
3210                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3211                         } else {
3212                                 r->parameters = NULL;
3213                         }
3214                         ndr->flags = _flags_save_string;
3215                 }
3216                 {
3217                         uint32_t _flags_save_string = ndr->flags;
3218                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3219                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3220                         if (_ptr_driver_name) {
3221                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3222                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3223                         } else {
3224                                 r->driver_name = NULL;
3225                         }
3226                         ndr->flags = _flags_save_string;
3227                 }
3228                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3229                 if (_ptr_devmode) {
3230                         NDR_PULL_ALLOC(ndr, r->devmode);
3231                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3232                 } else {
3233                         r->devmode = NULL;
3234                 }
3235                 {
3236                         uint32_t _flags_save_string = ndr->flags;
3237                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3238                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3239                         if (_ptr_text_status) {
3240                                 NDR_PULL_ALLOC(ndr, r->text_status);
3241                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3242                         } else {
3243                                 r->text_status = NULL;
3244                         }
3245                         ndr->flags = _flags_save_string;
3246                 }
3247                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3248                 if (_ptr_secdesc) {
3249                         NDR_PULL_ALLOC(ndr, r->secdesc);
3250                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3251                 } else {
3252                         r->secdesc = NULL;
3253                 }
3254                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3261                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3264         }
3265         if (ndr_flags & NDR_BUFFERS) {
3266                 {
3267                         uint32_t _flags_save_string = ndr->flags;
3268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3269                         if (r->printer_name) {
3270                                 uint32_t _relative_save_offset;
3271                                 _relative_save_offset = ndr->offset;
3272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3273                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3274                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3275                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3277                                 ndr->offset = _relative_save_offset;
3278                         }
3279                         ndr->flags = _flags_save_string;
3280                 }
3281                 {
3282                         uint32_t _flags_save_string = ndr->flags;
3283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3284                         if (r->server_name) {
3285                                 uint32_t _relative_save_offset;
3286                                 _relative_save_offset = ndr->offset;
3287                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3288                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3289                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3290                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3291                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3292                                 ndr->offset = _relative_save_offset;
3293                         }
3294                         ndr->flags = _flags_save_string;
3295                 }
3296                 {
3297                         uint32_t _flags_save_string = ndr->flags;
3298                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3299                         if (r->user_name) {
3300                                 uint32_t _relative_save_offset;
3301                                 _relative_save_offset = ndr->offset;
3302                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3303                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3304                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3305                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3306                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3307                                 ndr->offset = _relative_save_offset;
3308                         }
3309                         ndr->flags = _flags_save_string;
3310                 }
3311                 {
3312                         uint32_t _flags_save_string = ndr->flags;
3313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3314                         if (r->document_name) {
3315                                 uint32_t _relative_save_offset;
3316                                 _relative_save_offset = ndr->offset;
3317                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3318                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3319                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3320                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3321                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3322                                 ndr->offset = _relative_save_offset;
3323                         }
3324                         ndr->flags = _flags_save_string;
3325                 }
3326                 {
3327                         uint32_t _flags_save_string = ndr->flags;
3328                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3329                         if (r->notify_name) {
3330                                 uint32_t _relative_save_offset;
3331                                 _relative_save_offset = ndr->offset;
3332                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3333                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3334                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3335                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3336                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3337                                 ndr->offset = _relative_save_offset;
3338                         }
3339                         ndr->flags = _flags_save_string;
3340                 }
3341                 {
3342                         uint32_t _flags_save_string = ndr->flags;
3343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3344                         if (r->data_type) {
3345                                 uint32_t _relative_save_offset;
3346                                 _relative_save_offset = ndr->offset;
3347                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3348                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3349                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3350                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3351                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3352                                 ndr->offset = _relative_save_offset;
3353                         }
3354                         ndr->flags = _flags_save_string;
3355                 }
3356                 {
3357                         uint32_t _flags_save_string = ndr->flags;
3358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3359                         if (r->print_processor) {
3360                                 uint32_t _relative_save_offset;
3361                                 _relative_save_offset = ndr->offset;
3362                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3363                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3364                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3365                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3366                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3367                                 ndr->offset = _relative_save_offset;
3368                         }
3369                         ndr->flags = _flags_save_string;
3370                 }
3371                 {
3372                         uint32_t _flags_save_string = ndr->flags;
3373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3374                         if (r->parameters) {
3375                                 uint32_t _relative_save_offset;
3376                                 _relative_save_offset = ndr->offset;
3377                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3378                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3379                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3380                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3381                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3382                                 ndr->offset = _relative_save_offset;
3383                         }
3384                         ndr->flags = _flags_save_string;
3385                 }
3386                 {
3387                         uint32_t _flags_save_string = ndr->flags;
3388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3389                         if (r->driver_name) {
3390                                 uint32_t _relative_save_offset;
3391                                 _relative_save_offset = ndr->offset;
3392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3393                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3394                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3397                                 ndr->offset = _relative_save_offset;
3398                         }
3399                         ndr->flags = _flags_save_string;
3400                 }
3401                 if (r->devmode) {
3402                         uint32_t _relative_save_offset;
3403                         _relative_save_offset = ndr->offset;
3404                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3405                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3406                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3407                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3408                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3409                         ndr->offset = _relative_save_offset;
3410                 }
3411                 {
3412                         uint32_t _flags_save_string = ndr->flags;
3413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3414                         if (r->text_status) {
3415                                 uint32_t _relative_save_offset;
3416                                 _relative_save_offset = ndr->offset;
3417                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3418                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3419                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3420                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3421                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3422                                 ndr->offset = _relative_save_offset;
3423                         }
3424                         ndr->flags = _flags_save_string;
3425                 }
3426                 if (r->secdesc) {
3427                         uint32_t _relative_save_offset;
3428                         _relative_save_offset = ndr->offset;
3429                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3430                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3431                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3432                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3433                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3434                         ndr->offset = _relative_save_offset;
3435                 }
3436         }
3437         return NDR_ERR_SUCCESS;
3438 }
3439
3440 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3441 {
3442         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3443         ndr->depth++;
3444         ndr_print_uint32(ndr, "job_id", r->job_id);
3445         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3446         ndr->depth++;
3447         if (r->printer_name) {
3448                 ndr_print_string(ndr, "printer_name", r->printer_name);
3449         }
3450         ndr->depth--;
3451         ndr_print_ptr(ndr, "server_name", r->server_name);
3452         ndr->depth++;
3453         if (r->server_name) {
3454                 ndr_print_string(ndr, "server_name", r->server_name);
3455         }
3456         ndr->depth--;
3457         ndr_print_ptr(ndr, "user_name", r->user_name);
3458         ndr->depth++;
3459         if (r->user_name) {
3460                 ndr_print_string(ndr, "user_name", r->user_name);
3461         }
3462         ndr->depth--;
3463         ndr_print_ptr(ndr, "document_name", r->document_name);
3464         ndr->depth++;
3465         if (r->document_name) {
3466                 ndr_print_string(ndr, "document_name", r->document_name);
3467         }
3468         ndr->depth--;
3469         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3470         ndr->depth++;
3471         if (r->notify_name) {
3472                 ndr_print_string(ndr, "notify_name", r->notify_name);
3473         }
3474         ndr->depth--;
3475         ndr_print_ptr(ndr, "data_type", r->data_type);
3476         ndr->depth++;
3477         if (r->data_type) {
3478                 ndr_print_string(ndr, "data_type", r->data_type);
3479         }
3480         ndr->depth--;
3481         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3482         ndr->depth++;
3483         if (r->print_processor) {
3484                 ndr_print_string(ndr, "print_processor", r->print_processor);
3485         }
3486         ndr->depth--;
3487         ndr_print_ptr(ndr, "parameters", r->parameters);
3488         ndr->depth++;
3489         if (r->parameters) {
3490                 ndr_print_string(ndr, "parameters", r->parameters);
3491         }
3492         ndr->depth--;
3493         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3494         ndr->depth++;
3495         if (r->driver_name) {
3496                 ndr_print_string(ndr, "driver_name", r->driver_name);
3497         }
3498         ndr->depth--;
3499         ndr_print_ptr(ndr, "devmode", r->devmode);
3500         ndr->depth++;
3501         if (r->devmode) {
3502                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3503         }
3504         ndr->depth--;
3505         ndr_print_ptr(ndr, "text_status", r->text_status);
3506         ndr->depth++;
3507         if (r->text_status) {
3508                 ndr_print_string(ndr, "text_status", r->text_status);
3509         }
3510         ndr->depth--;
3511         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3512         ndr->depth++;
3513         if (r->secdesc) {
3514                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3515         }
3516         ndr->depth--;
3517         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3518         ndr_print_uint32(ndr, "priority", r->priority);
3519         ndr_print_uint32(ndr, "position", r->position);
3520         ndr_print_uint32(ndr, "start_time", r->start_time);
3521         ndr_print_uint32(ndr, "until_time", r->until_time);
3522         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3523         ndr_print_uint32(ndr, "size", r->size);
3524         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3525         ndr_print_uint32(ndr, "time", r->time);
3526         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3527         ndr->depth--;
3528 }
3529
3530 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
3531 {
3532         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
3533 }
3534
3535 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3536 {
3537         if (ndr_flags & NDR_SCALARS) {
3538                 NDR_CHECK(ndr_push_align(ndr, 4));
3539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3542         }
3543         if (ndr_flags & NDR_BUFFERS) {
3544         }
3545         return NDR_ERR_SUCCESS;
3546 }
3547
3548 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3549 {
3550         if (ndr_flags & NDR_SCALARS) {
3551                 NDR_CHECK(ndr_pull_align(ndr, 4));
3552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3554                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3555         }
3556         if (ndr_flags & NDR_BUFFERS) {
3557         }
3558         return NDR_ERR_SUCCESS;
3559 }
3560
3561 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3562 {
3563         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3564         ndr->depth++;
3565         ndr_print_uint32(ndr, "job_id", r->job_id);
3566         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3567         ndr_print_uint32(ndr, "reserved", r->reserved);
3568         ndr->depth--;
3569 }
3570
3571 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
3572 {
3573         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
3574 }
3575
3576 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3577 {
3578         if (ndr_flags & NDR_SCALARS) {
3579                 NDR_CHECK(ndr_push_align(ndr, 4));
3580                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3581                 {
3582                         uint32_t _flags_save_string = ndr->flags;
3583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3584                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3585                         ndr->flags = _flags_save_string;
3586                 }
3587                 {
3588                         uint32_t _flags_save_string = ndr->flags;
3589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3590                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3591                         ndr->flags = _flags_save_string;
3592                 }
3593                 {
3594                         uint32_t _flags_save_string = ndr->flags;
3595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3596                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3597                         ndr->flags = _flags_save_string;
3598                 }
3599                 {
3600                         uint32_t _flags_save_string = ndr->flags;
3601                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3602                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3603                         ndr->flags = _flags_save_string;
3604                 }
3605                 {
3606                         uint32_t _flags_save_string = ndr->flags;
3607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3608                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3609                         ndr->flags = _flags_save_string;
3610                 }
3611                 {
3612                         uint32_t _flags_save_string = ndr->flags;
3613                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3614                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3615                         ndr->flags = _flags_save_string;
3616                 }
3617                 {
3618                         uint32_t _flags_save_string = ndr->flags;
3619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3620                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3621                         ndr->flags = _flags_save_string;
3622                 }
3623                 {
3624                         uint32_t _flags_save_string = ndr->flags;
3625                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3626                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3627                         ndr->flags = _flags_save_string;
3628                 }
3629                 {
3630                         uint32_t _flags_save_string = ndr->flags;
3631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3632                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3633                         ndr->flags = _flags_save_string;
3634                 }
3635                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3636                 {
3637                         uint32_t _flags_save_string = ndr->flags;
3638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3639                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3640                         ndr->flags = _flags_save_string;
3641                 }
3642                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3643                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3650                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3652                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3654         }
3655         if (ndr_flags & NDR_BUFFERS) {
3656                 {
3657                         uint32_t _flags_save_string = ndr->flags;
3658                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3659                         if (r->printer_name) {
3660                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3661                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3662                         }
3663                         ndr->flags = _flags_save_string;
3664                 }
3665                 {
3666                         uint32_t _flags_save_string = ndr->flags;
3667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3668                         if (r->server_name) {
3669                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3670                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3671                         }
3672                         ndr->flags = _flags_save_string;
3673                 }
3674                 {
3675                         uint32_t _flags_save_string = ndr->flags;
3676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3677                         if (r->user_name) {
3678                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3679                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3680                         }
3681                         ndr->flags = _flags_save_string;
3682                 }
3683                 {
3684                         uint32_t _flags_save_string = ndr->flags;
3685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3686                         if (r->document_name) {
3687                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3688                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3689                         }
3690                         ndr->flags = _flags_save_string;
3691                 }
3692                 {
3693                         uint32_t _flags_save_string = ndr->flags;
3694                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3695                         if (r->notify_name) {
3696                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3697                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3698                         }
3699                         ndr->flags = _flags_save_string;
3700                 }
3701                 {
3702                         uint32_t _flags_save_string = ndr->flags;
3703                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3704                         if (r->data_type) {
3705                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3706                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3707                         }
3708                         ndr->flags = _flags_save_string;
3709                 }
3710                 {
3711                         uint32_t _flags_save_string = ndr->flags;
3712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3713                         if (r->print_processor) {
3714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3716                         }
3717                         ndr->flags = _flags_save_string;
3718                 }
3719                 {
3720                         uint32_t _flags_save_string = ndr->flags;
3721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3722                         if (r->parameters) {
3723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3725                         }
3726                         ndr->flags = _flags_save_string;
3727                 }
3728                 {
3729                         uint32_t _flags_save_string = ndr->flags;
3730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3731                         if (r->driver_name) {
3732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3734                         }
3735                         ndr->flags = _flags_save_string;
3736                 }
3737                 if (r->devmode) {
3738                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3739                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3740                 }
3741                 {
3742                         uint32_t _flags_save_string = ndr->flags;
3743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3744                         if (r->text_status) {
3745                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3746                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3747                         }
3748                         ndr->flags = _flags_save_string;
3749                 }
3750                 if (r->secdesc) {
3751                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3752                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3753                 }
3754         }
3755         return NDR_ERR_SUCCESS;
3756 }
3757
3758 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3759 {
3760         uint32_t _ptr_printer_name;
3761         TALLOC_CTX *_mem_save_printer_name_0;
3762         uint32_t _ptr_server_name;
3763         TALLOC_CTX *_mem_save_server_name_0;
3764         uint32_t _ptr_user_name;
3765         TALLOC_CTX *_mem_save_user_name_0;
3766         uint32_t _ptr_document_name;
3767         TALLOC_CTX *_mem_save_document_name_0;
3768         uint32_t _ptr_notify_name;
3769         TALLOC_CTX *_mem_save_notify_name_0;
3770         uint32_t _ptr_data_type;
3771         TALLOC_CTX *_mem_save_data_type_0;
3772         uint32_t _ptr_print_processor;
3773         TALLOC_CTX *_mem_save_print_processor_0;
3774         uint32_t _ptr_parameters;
3775         TALLOC_CTX *_mem_save_parameters_0;
3776         uint32_t _ptr_driver_name;
3777         TALLOC_CTX *_mem_save_driver_name_0;
3778         uint32_t _ptr_devmode;
3779         TALLOC_CTX *_mem_save_devmode_0;
3780         uint32_t _ptr_text_status;
3781         TALLOC_CTX *_mem_save_text_status_0;
3782         uint32_t _ptr_secdesc;
3783         TALLOC_CTX *_mem_save_secdesc_0;
3784         if (ndr_flags & NDR_SCALARS) {
3785                 NDR_CHECK(ndr_pull_align(ndr, 4));
3786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3787                 {
3788                         uint32_t _flags_save_string = ndr->flags;
3789                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3790                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3791                         if (_ptr_printer_name) {
3792                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3793                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3794                         } else {
3795                                 r->printer_name = NULL;
3796                         }
3797                         ndr->flags = _flags_save_string;
3798                 }
3799                 {
3800                         uint32_t _flags_save_string = ndr->flags;
3801                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3802                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3803                         if (_ptr_server_name) {
3804                                 NDR_PULL_ALLOC(ndr, r->server_name);
3805                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3806                         } else {
3807                                 r->server_name = NULL;
3808                         }
3809                         ndr->flags = _flags_save_string;
3810                 }
3811                 {
3812                         uint32_t _flags_save_string = ndr->flags;
3813                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3814                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3815                         if (_ptr_user_name) {
3816                                 NDR_PULL_ALLOC(ndr, r->user_name);
3817                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3818                         } else {
3819                                 r->user_name = NULL;
3820                         }
3821                         ndr->flags = _flags_save_string;
3822                 }
3823                 {
3824                         uint32_t _flags_save_string = ndr->flags;
3825                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3826                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3827                         if (_ptr_document_name) {
3828                                 NDR_PULL_ALLOC(ndr, r->document_name);
3829                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3830                         } else {
3831                                 r->document_name = NULL;
3832                         }
3833                         ndr->flags = _flags_save_string;
3834                 }
3835                 {
3836                         uint32_t _flags_save_string = ndr->flags;
3837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3838                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3839                         if (_ptr_notify_name) {
3840                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3841                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3842                         } else {
3843                                 r->notify_name = NULL;
3844                         }
3845                         ndr->flags = _flags_save_string;
3846                 }
3847                 {
3848                         uint32_t _flags_save_string = ndr->flags;
3849                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3850                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3851                         if (_ptr_data_type) {
3852                                 NDR_PULL_ALLOC(ndr, r->data_type);
3853                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3854                         } else {
3855                                 r->data_type = NULL;
3856                         }
3857                         ndr->flags = _flags_save_string;
3858                 }
3859                 {
3860                         uint32_t _flags_save_string = ndr->flags;
3861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3862                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3863                         if (_ptr_print_processor) {
3864                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3865                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3866                         } else {
3867                                 r->print_processor = NULL;
3868                         }
3869                         ndr->flags = _flags_save_string;
3870                 }
3871                 {
3872                         uint32_t _flags_save_string = ndr->flags;
3873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3874                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3875                         if (_ptr_parameters) {
3876                                 NDR_PULL_ALLOC(ndr, r->parameters);
3877                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3878                         } else {
3879                                 r->parameters = NULL;
3880                         }
3881                         ndr->flags = _flags_save_string;
3882                 }
3883                 {
3884                         uint32_t _flags_save_string = ndr->flags;
3885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3886                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3887                         if (_ptr_driver_name) {
3888                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3889                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3890                         } else {
3891                                 r->driver_name = NULL;
3892                         }
3893                         ndr->flags = _flags_save_string;
3894                 }
3895                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3896                 if (_ptr_devmode) {
3897                         NDR_PULL_ALLOC(ndr, r->devmode);
3898                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3899                 } else {
3900                         r->devmode = NULL;
3901                 }
3902                 {
3903                         uint32_t _flags_save_string = ndr->flags;
3904                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3905                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3906                         if (_ptr_text_status) {
3907                                 NDR_PULL_ALLOC(ndr, r->text_status);
3908                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3909                         } else {
3910                                 r->text_status = NULL;
3911                         }
3912                         ndr->flags = _flags_save_string;
3913                 }
3914                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3915                 if (_ptr_secdesc) {
3916                         NDR_PULL_ALLOC(ndr, r->secdesc);
3917                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3918                 } else {
3919                         r->secdesc = NULL;
3920                 }
3921                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3927                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3928                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3932         }
3933         if (ndr_flags & NDR_BUFFERS) {
3934                 {
3935                         uint32_t _flags_save_string = ndr->flags;
3936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3937                         if (r->printer_name) {
3938                                 uint32_t _relative_save_offset;
3939                                 _relative_save_offset = ndr->offset;
3940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3941                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3942                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3945                                 ndr->offset = _relative_save_offset;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 {
3950                         uint32_t _flags_save_string = ndr->flags;
3951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3952                         if (r->server_name) {
3953                                 uint32_t _relative_save_offset;
3954                                 _relative_save_offset = ndr->offset;
3955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3956                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3957                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3958                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3959                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3960                                 ndr->offset = _relative_save_offset;
3961                         }
3962                         ndr->flags = _flags_save_string;
3963                 }
3964                 {
3965                         uint32_t _flags_save_string = ndr->flags;
3966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3967                         if (r->user_name) {
3968                                 uint32_t _relative_save_offset;
3969                                 _relative_save_offset = ndr->offset;
3970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3971                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3972                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3975                                 ndr->offset = _relative_save_offset;
3976                         }
3977                         ndr->flags = _flags_save_string;
3978                 }
3979                 {
3980                         uint32_t _flags_save_string = ndr->flags;
3981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3982                         if (r->document_name) {
3983                                 uint32_t _relative_save_offset;
3984                                 _relative_save_offset = ndr->offset;
3985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3986                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3987                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3990                                 ndr->offset = _relative_save_offset;
3991                         }
3992                         ndr->flags = _flags_save_string;
3993                 }
3994                 {
3995                         uint32_t _flags_save_string = ndr->flags;
3996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3997                         if (r->notify_name) {
3998                                 uint32_t _relative_save_offset;
3999                                 _relative_save_offset = ndr->offset;
4000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4001                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4002                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4003                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4005                                 ndr->offset = _relative_save_offset;
4006                         }
4007                         ndr->flags = _flags_save_string;
4008                 }
4009                 {
4010                         uint32_t _flags_save_string = ndr->flags;
4011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4012                         if (r->data_type) {
4013                                 uint32_t _relative_save_offset;
4014                                 _relative_save_offset = ndr->offset;
4015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4016                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4017                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4020                                 ndr->offset = _relative_save_offset;
4021                         }
4022                         ndr->flags = _flags_save_string;
4023                 }
4024                 {
4025                         uint32_t _flags_save_string = ndr->flags;
4026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4027                         if (r->print_processor) {
4028                                 uint32_t _relative_save_offset;
4029                                 _relative_save_offset = ndr->offset;
4030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4031                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4032                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4035                                 ndr->offset = _relative_save_offset;
4036                         }
4037                         ndr->flags = _flags_save_string;
4038                 }
4039                 {
4040                         uint32_t _flags_save_string = ndr->flags;
4041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4042                         if (r->parameters) {
4043                                 uint32_t _relative_save_offset;
4044                                 _relative_save_offset = ndr->offset;
4045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4046                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4047                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4050                                 ndr->offset = _relative_save_offset;
4051                         }
4052                         ndr->flags = _flags_save_string;
4053                 }
4054                 {
4055                         uint32_t _flags_save_string = ndr->flags;
4056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4057                         if (r->driver_name) {
4058                                 uint32_t _relative_save_offset;
4059                                 _relative_save_offset = ndr->offset;
4060                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4061                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4062                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4063                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4064                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4065                                 ndr->offset = _relative_save_offset;
4066                         }
4067                         ndr->flags = _flags_save_string;
4068                 }
4069                 if (r->devmode) {
4070                         uint32_t _relative_save_offset;
4071                         _relative_save_offset = ndr->offset;
4072                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4073                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4074                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4075                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4076                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4077                         ndr->offset = _relative_save_offset;
4078                 }
4079                 {
4080                         uint32_t _flags_save_string = ndr->flags;
4081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4082                         if (r->text_status) {
4083                                 uint32_t _relative_save_offset;
4084                                 _relative_save_offset = ndr->offset;
4085                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4086                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4087                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4088                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4089                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4090                                 ndr->offset = _relative_save_offset;
4091                         }
4092                         ndr->flags = _flags_save_string;
4093                 }
4094                 if (r->secdesc) {
4095                         uint32_t _relative_save_offset;
4096                         _relative_save_offset = ndr->offset;
4097                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4098                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4099                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4100                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4102                         ndr->offset = _relative_save_offset;
4103                 }
4104         }
4105         return NDR_ERR_SUCCESS;
4106 }
4107
4108 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4109 {
4110         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4111         ndr->depth++;
4112         ndr_print_uint32(ndr, "job_id", r->job_id);
4113         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4114         ndr->depth++;
4115         if (r->printer_name) {
4116                 ndr_print_string(ndr, "printer_name", r->printer_name);
4117         }
4118         ndr->depth--;
4119         ndr_print_ptr(ndr, "server_name", r->server_name);
4120         ndr->depth++;
4121         if (r->server_name) {
4122                 ndr_print_string(ndr, "server_name", r->server_name);
4123         }
4124         ndr->depth--;
4125         ndr_print_ptr(ndr, "user_name", r->user_name);
4126         ndr->depth++;
4127         if (r->user_name) {
4128                 ndr_print_string(ndr, "user_name", r->user_name);
4129         }
4130         ndr->depth--;
4131         ndr_print_ptr(ndr, "document_name", r->document_name);
4132         ndr->depth++;
4133         if (r->document_name) {
4134                 ndr_print_string(ndr, "document_name", r->document_name);
4135         }
4136         ndr->depth--;
4137         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4138         ndr->depth++;
4139         if (r->notify_name) {
4140                 ndr_print_string(ndr, "notify_name", r->notify_name);
4141         }
4142         ndr->depth--;
4143         ndr_print_ptr(ndr, "data_type", r->data_type);
4144         ndr->depth++;
4145         if (r->data_type) {
4146                 ndr_print_string(ndr, "data_type", r->data_type);
4147         }
4148         ndr->depth--;
4149         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4150         ndr->depth++;
4151         if (r->print_processor) {
4152                 ndr_print_string(ndr, "print_processor", r->print_processor);
4153         }
4154         ndr->depth--;
4155         ndr_print_ptr(ndr, "parameters", r->parameters);
4156         ndr->depth++;
4157         if (r->parameters) {
4158                 ndr_print_string(ndr, "parameters", r->parameters);
4159         }
4160         ndr->depth--;
4161         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4162         ndr->depth++;
4163         if (r->driver_name) {
4164                 ndr_print_string(ndr, "driver_name", r->driver_name);
4165         }
4166         ndr->depth--;
4167         ndr_print_ptr(ndr, "devmode", r->devmode);
4168         ndr->depth++;
4169         if (r->devmode) {
4170                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4171         }
4172         ndr->depth--;
4173         ndr_print_ptr(ndr, "text_status", r->text_status);
4174         ndr->depth++;
4175         if (r->text_status) {
4176                 ndr_print_string(ndr, "text_status", r->text_status);
4177         }
4178         ndr->depth--;
4179         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4180         ndr->depth++;
4181         if (r->secdesc) {
4182                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4183         }
4184         ndr->depth--;
4185         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4186         ndr_print_uint32(ndr, "priority", r->priority);
4187         ndr_print_uint32(ndr, "position", r->position);
4188         ndr_print_uint32(ndr, "start_time", r->start_time);
4189         ndr_print_uint32(ndr, "until_time", r->until_time);
4190         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4191         ndr_print_uint32(ndr, "size", r->size);
4192         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4193         ndr_print_uint32(ndr, "time", r->time);
4194         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4195         ndr_print_uint32(ndr, "size_high", r->size_high);
4196         ndr->depth--;
4197 }
4198
4199 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4200 {
4201         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4202 }
4203
4204 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4205 {
4206         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4207         if (ndr_flags & NDR_SCALARS) {
4208                 int level = ndr_push_get_switch_value(ndr, r);
4209                 switch (level) {
4210                         case 1: {
4211                                 NDR_CHECK(ndr_push_align(ndr, 4));
4212                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4213                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4214                         break; }
4215
4216                         case 2: {
4217                                 NDR_CHECK(ndr_push_align(ndr, 4));
4218                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4219                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4220                         break; }
4221
4222                         case 3: {
4223                                 NDR_CHECK(ndr_push_align(ndr, 4));
4224                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4225                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4226                         break; }
4227
4228                         case 4: {
4229                                 NDR_CHECK(ndr_push_align(ndr, 4));
4230                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4231                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4232                         break; }
4233
4234                         default: {
4235                         break; }
4236
4237                 }
4238         }
4239         if (ndr_flags & NDR_BUFFERS) {
4240                 int level = ndr_push_get_switch_value(ndr, r);
4241                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4242                 switch (level) {
4243                         case 1:
4244                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4245                         break;
4246
4247                         case 2:
4248                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4249                         break;
4250
4251                         case 3:
4252                         break;
4253
4254                         case 4:
4255                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4256                         break;
4257
4258                         default:
4259                         break;
4260
4261                 }
4262         }
4263         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4264         return NDR_ERR_SUCCESS;
4265 }
4266
4267 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4268 {
4269         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4270         int level;
4271         level = ndr_pull_get_switch_value(ndr, r);
4272         if (ndr_flags & NDR_SCALARS) {
4273                 switch (level) {
4274                         case 1: {
4275                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4276                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4277                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4278                         break; }
4279
4280                         case 2: {
4281                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4282                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4283                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4284                         break; }
4285
4286                         case 3: {
4287                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4288                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4289                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4290                         break; }
4291
4292                         case 4: {
4293                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4294                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4295                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4296                         break; }
4297
4298                         default: {
4299                         break; }
4300
4301                 }
4302         }
4303         if (ndr_flags & NDR_BUFFERS) {
4304                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4305                 switch (level) {
4306                         case 1:
4307                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4308                         break;
4309
4310                         case 2:
4311                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4312                         break;
4313
4314                         case 3:
4315                         break;
4316
4317                         case 4:
4318                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4319                         break;
4320
4321                         default:
4322                         break;
4323
4324                 }
4325         }
4326         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4327         return NDR_ERR_SUCCESS;
4328 }
4329
4330 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4331 {
4332         int level;
4333         level = ndr_print_get_switch_value(ndr, r);
4334         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4335         switch (level) {
4336                 case 1:
4337                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4338                 break;
4339
4340                 case 2:
4341                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4342                 break;
4343
4344                 case 3:
4345                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4346                 break;
4347
4348                 case 4:
4349                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4350                 break;
4351
4352                 default:
4353                 break;
4354
4355         }
4356 }
4357
4358 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4359 {
4360         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4361 }
4362
4363 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4364 {
4365         if (ndr_flags & NDR_SCALARS) {
4366                 NDR_CHECK(ndr_push_align(ndr, 4));
4367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4368                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4369                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4370                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4371                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4372                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4373                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4374                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4377                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4378                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4379                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4380         }
4381         if (ndr_flags & NDR_BUFFERS) {
4382                 if (r->printer_name) {
4383                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4384                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4385                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4386                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4387                 }
4388                 if (r->server_name) {
4389                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4390                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4391                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4392                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4393                 }
4394                 if (r->user_name) {
4395                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4399                 }
4400                 if (r->document_name) {
4401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4405                 }
4406                 if (r->data_type) {
4407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4411                 }
4412                 if (r->text_status) {
4413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4416                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4417                 }
4418         }
4419         return NDR_ERR_SUCCESS;
4420 }
4421
4422 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4423 {
4424         uint32_t _ptr_printer_name;
4425         TALLOC_CTX *_mem_save_printer_name_0;
4426         uint32_t _ptr_server_name;
4427         TALLOC_CTX *_mem_save_server_name_0;
4428         uint32_t _ptr_user_name;
4429         TALLOC_CTX *_mem_save_user_name_0;
4430         uint32_t _ptr_document_name;
4431         TALLOC_CTX *_mem_save_document_name_0;
4432         uint32_t _ptr_data_type;
4433         TALLOC_CTX *_mem_save_data_type_0;
4434         uint32_t _ptr_text_status;
4435         TALLOC_CTX *_mem_save_text_status_0;
4436         if (ndr_flags & NDR_SCALARS) {
4437                 NDR_CHECK(ndr_pull_align(ndr, 4));
4438                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4439                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4440                 if (_ptr_printer_name) {
4441                         NDR_PULL_ALLOC(ndr, r->printer_name);
4442                 } else {
4443                         r->printer_name = NULL;
4444                 }
4445                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4446                 if (_ptr_server_name) {
4447                         NDR_PULL_ALLOC(ndr, r->server_name);
4448                 } else {
4449                         r->server_name = NULL;
4450                 }
4451                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4452                 if (_ptr_user_name) {
4453                         NDR_PULL_ALLOC(ndr, r->user_name);
4454                 } else {
4455                         r->user_name = NULL;
4456                 }
4457                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4458                 if (_ptr_document_name) {
4459                         NDR_PULL_ALLOC(ndr, r->document_name);
4460                 } else {
4461                         r->document_name = NULL;
4462                 }
4463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4464                 if (_ptr_data_type) {
4465                         NDR_PULL_ALLOC(ndr, r->data_type);
4466                 } else {
4467                         r->data_type = NULL;
4468                 }
4469                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4470                 if (_ptr_text_status) {
4471                         NDR_PULL_ALLOC(ndr, r->text_status);
4472                 } else {
4473                         r->text_status = NULL;
4474                 }
4475                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4480                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4481         }
4482         if (ndr_flags & NDR_BUFFERS) {
4483                 if (r->printer_name) {
4484                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4485                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4486                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4487                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4488                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4489                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
4490                         }
4491                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4492                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4493                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4494                 }
4495                 if (r->server_name) {
4496                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4497                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4498                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4499                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4500                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4501                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
4502                         }
4503                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4504                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4505                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4506                 }
4507                 if (r->user_name) {
4508                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4509                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4510                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4511                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4512                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4513                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4514                         }
4515                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4516                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4518                 }
4519                 if (r->document_name) {
4520                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4521                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4522                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4523                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4524                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4525                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
4526                         }
4527                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4528                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4529                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4530                 }
4531                 if (r->data_type) {
4532                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4533                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4534                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4535                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4536                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4537                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
4538                         }
4539                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4540                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4541                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4542                 }
4543                 if (r->text_status) {
4544                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4545                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4546                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4547                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4548                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4549                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
4550                         }
4551                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4552                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4554                 }
4555         }
4556         return NDR_ERR_SUCCESS;
4557 }
4558
4559 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4560 {
4561         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4562         ndr->depth++;
4563         ndr_print_uint32(ndr, "job_id", r->job_id);
4564         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4565         ndr->depth++;
4566         if (r->printer_name) {
4567                 ndr_print_string(ndr, "printer_name", r->printer_name);
4568         }
4569         ndr->depth--;
4570         ndr_print_ptr(ndr, "server_name", r->server_name);
4571         ndr->depth++;
4572         if (r->server_name) {
4573                 ndr_print_string(ndr, "server_name", r->server_name);
4574         }
4575         ndr->depth--;
4576         ndr_print_ptr(ndr, "user_name", r->user_name);
4577         ndr->depth++;
4578         if (r->user_name) {
4579                 ndr_print_string(ndr, "user_name", r->user_name);
4580         }
4581         ndr->depth--;
4582         ndr_print_ptr(ndr, "document_name", r->document_name);
4583         ndr->depth++;
4584         if (r->document_name) {
4585                 ndr_print_string(ndr, "document_name", r->document_name);
4586         }
4587         ndr->depth--;
4588         ndr_print_ptr(ndr, "data_type", r->data_type);
4589         ndr->depth++;
4590         if (r->data_type) {
4591                 ndr_print_string(ndr, "data_type", r->data_type);
4592         }
4593         ndr->depth--;
4594         ndr_print_ptr(ndr, "text_status", r->text_status);
4595         ndr->depth++;
4596         if (r->text_status) {
4597                 ndr_print_string(ndr, "text_status", r->text_status);
4598         }
4599         ndr->depth--;
4600         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4601         ndr_print_uint32(ndr, "priority", r->priority);
4602         ndr_print_uint32(ndr, "position", r->position);
4603         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4604         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4605         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4606         ndr->depth--;
4607 }
4608
4609 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4610 {
4611         if (ndr_flags & NDR_SCALARS) {
4612                 NDR_CHECK(ndr_push_align(ndr, 4));
4613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4614                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4615                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4616                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4617                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4619                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4621                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4623                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4624                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4625                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4626                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4633                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4636         }
4637         if (ndr_flags & NDR_BUFFERS) {
4638                 if (r->printer_name) {
4639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4640                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4641                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4642                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4643                 }
4644                 if (r->server_name) {
4645                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4646                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4647                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4648                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4649                 }
4650                 if (r->user_name) {
4651                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4652                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4653                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4654                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4655                 }
4656                 if (r->document_name) {
4657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4659                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4661                 }
4662                 if (r->notify_name) {
4663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4664                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4665                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4666                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4667                 }
4668                 if (r->data_type) {
4669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4671                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4672                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4673                 }
4674                 if (r->print_processor) {
4675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4676                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4677                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4678                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4679                 }
4680                 if (r->parameters) {
4681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4683                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4684                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4685                 }
4686                 if (r->driver_name) {
4687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4689                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4690                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4691                 }
4692                 if (r->text_status) {
4693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4694                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4695                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4696                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4697                 }
4698         }
4699         return NDR_ERR_SUCCESS;
4700 }
4701
4702 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4703 {
4704         uint32_t _ptr_printer_name;
4705         TALLOC_CTX *_mem_save_printer_name_0;
4706         uint32_t _ptr_server_name;
4707         TALLOC_CTX *_mem_save_server_name_0;
4708         uint32_t _ptr_user_name;
4709         TALLOC_CTX *_mem_save_user_name_0;
4710         uint32_t _ptr_document_name;
4711         TALLOC_CTX *_mem_save_document_name_0;
4712         uint32_t _ptr_notify_name;
4713         TALLOC_CTX *_mem_save_notify_name_0;
4714         uint32_t _ptr_data_type;
4715         TALLOC_CTX *_mem_save_data_type_0;
4716         uint32_t _ptr_print_processor;
4717         TALLOC_CTX *_mem_save_print_processor_0;
4718         uint32_t _ptr_parameters;
4719         TALLOC_CTX *_mem_save_parameters_0;
4720         uint32_t _ptr_driver_name;
4721         TALLOC_CTX *_mem_save_driver_name_0;
4722         uint32_t _ptr_text_status;
4723         TALLOC_CTX *_mem_save_text_status_0;
4724         if (ndr_flags & NDR_SCALARS) {
4725                 NDR_CHECK(ndr_pull_align(ndr, 4));
4726                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4727                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4728                 if (_ptr_printer_name) {
4729                         NDR_PULL_ALLOC(ndr, r->printer_name);
4730                 } else {
4731                         r->printer_name = NULL;
4732                 }
4733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4734                 if (_ptr_server_name) {
4735                         NDR_PULL_ALLOC(ndr, r->server_name);
4736                 } else {
4737                         r->server_name = NULL;
4738                 }
4739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4740                 if (_ptr_user_name) {
4741                         NDR_PULL_ALLOC(ndr, r->user_name);
4742                 } else {
4743                         r->user_name = NULL;
4744                 }
4745                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4746                 if (_ptr_document_name) {
4747                         NDR_PULL_ALLOC(ndr, r->document_name);
4748                 } else {
4749                         r->document_name = NULL;
4750                 }
4751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4752                 if (_ptr_notify_name) {
4753                         NDR_PULL_ALLOC(ndr, r->notify_name);
4754                 } else {
4755                         r->notify_name = NULL;
4756                 }
4757                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4758                 if (_ptr_data_type) {
4759                         NDR_PULL_ALLOC(ndr, r->data_type);
4760                 } else {
4761                         r->data_type = NULL;
4762                 }
4763                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4764                 if (_ptr_print_processor) {
4765                         NDR_PULL_ALLOC(ndr, r->print_processor);
4766                 } else {
4767                         r->print_processor = NULL;
4768                 }
4769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4770                 if (_ptr_parameters) {
4771                         NDR_PULL_ALLOC(ndr, r->parameters);
4772                 } else {
4773                         r->parameters = NULL;
4774                 }
4775                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4776                 if (_ptr_driver_name) {
4777                         NDR_PULL_ALLOC(ndr, r->driver_name);
4778                 } else {
4779                         r->driver_name = NULL;
4780                 }
4781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4782                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4783                 if (_ptr_text_status) {
4784                         NDR_PULL_ALLOC(ndr, r->text_status);
4785                 } else {
4786                         r->text_status = NULL;
4787                 }
4788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4789                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4796                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4799         }
4800         if (ndr_flags & NDR_BUFFERS) {
4801                 if (r->printer_name) {
4802                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4803                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4804                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4805                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4806                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4807                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
4808                         }
4809                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4810                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4812                 }
4813                 if (r->server_name) {
4814                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4815                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4816                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4817                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4818                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4819                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
4820                         }
4821                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4822                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4824                 }
4825                 if (r->user_name) {
4826                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4827                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4830                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4831                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4832                         }
4833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4836                 }
4837                 if (r->document_name) {
4838                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4839                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4842                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4843                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
4844                         }
4845                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4848                 }
4849                 if (r->notify_name) {
4850                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4851                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4854                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4855                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
4856                         }
4857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4860                 }
4861                 if (r->data_type) {
4862                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4863                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4864                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4865                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4866                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4867                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
4868                         }
4869                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4870                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4872                 }
4873                 if (r->print_processor) {
4874                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4875                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4876                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4877                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4878                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4879                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
4880                         }
4881                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4882                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4884                 }
4885                 if (r->parameters) {
4886                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4887                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4888                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4889                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4890                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4891                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
4892                         }
4893                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4894                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4895                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4896                 }
4897                 if (r->driver_name) {
4898                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4899                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4900                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4901                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4902                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4903                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4904                         }
4905                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4906                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4907                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4908                 }
4909                 if (r->text_status) {
4910                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4911                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4912                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4913                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4914                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4915                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
4916                         }
4917                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4918                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4919                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4920                 }
4921         }
4922         return NDR_ERR_SUCCESS;
4923 }
4924
4925 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4926 {
4927         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4928         ndr->depth++;
4929         ndr_print_uint32(ndr, "job_id", r->job_id);
4930         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4931         ndr->depth++;
4932         if (r->printer_name) {
4933                 ndr_print_string(ndr, "printer_name", r->printer_name);
4934         }
4935         ndr->depth--;
4936         ndr_print_ptr(ndr, "server_name", r->server_name);
4937         ndr->depth++;
4938         if (r->server_name) {
4939                 ndr_print_string(ndr, "server_name", r->server_name);
4940         }
4941         ndr->depth--;
4942         ndr_print_ptr(ndr, "user_name", r->user_name);
4943         ndr->depth++;
4944         if (r->user_name) {
4945                 ndr_print_string(ndr, "user_name", r->user_name);
4946         }
4947         ndr->depth--;
4948         ndr_print_ptr(ndr, "document_name", r->document_name);
4949         ndr->depth++;
4950         if (r->document_name) {
4951                 ndr_print_string(ndr, "document_name", r->document_name);
4952         }
4953         ndr->depth--;
4954         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4955         ndr->depth++;
4956         if (r->notify_name) {
4957                 ndr_print_string(ndr, "notify_name", r->notify_name);
4958         }
4959         ndr->depth--;
4960         ndr_print_ptr(ndr, "data_type", r->data_type);
4961         ndr->depth++;
4962         if (r->data_type) {
4963                 ndr_print_string(ndr, "data_type", r->data_type);
4964         }
4965         ndr->depth--;
4966         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4967         ndr->depth++;
4968         if (r->print_processor) {
4969                 ndr_print_string(ndr, "print_processor", r->print_processor);
4970         }
4971         ndr->depth--;
4972         ndr_print_ptr(ndr, "parameters", r->parameters);
4973         ndr->depth++;
4974         if (r->parameters) {
4975                 ndr_print_string(ndr, "parameters", r->parameters);
4976         }
4977         ndr->depth--;
4978         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4979         ndr->depth++;
4980         if (r->driver_name) {
4981                 ndr_print_string(ndr, "driver_name", r->driver_name);
4982         }
4983         ndr->depth--;
4984         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
4985         ndr_print_ptr(ndr, "text_status", r->text_status);
4986         ndr->depth++;
4987         if (r->text_status) {
4988                 ndr_print_string(ndr, "text_status", r->text_status);
4989         }
4990         ndr->depth--;
4991         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
4992         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4993         ndr_print_uint32(ndr, "priority", r->priority);
4994         ndr_print_uint32(ndr, "position", r->position);
4995         ndr_print_uint32(ndr, "start_time", r->start_time);
4996         ndr_print_uint32(ndr, "until_time", r->until_time);
4997         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4998         ndr_print_uint32(ndr, "size", r->size);
4999         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5000         ndr_print_uint32(ndr, "time", r->time);
5001         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5002         ndr->depth--;
5003 }
5004
5005 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5006 {
5007         if (ndr_flags & NDR_SCALARS) {
5008                 NDR_CHECK(ndr_push_align(ndr, 4));
5009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5011                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5012                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5016                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5018                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5021                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5022                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5029                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5033         }
5034         if (ndr_flags & NDR_BUFFERS) {
5035                 if (r->printer_name) {
5036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5037                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5039                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5040                 }
5041                 if (r->server_name) {
5042                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5043                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5044                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5045                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5046                 }
5047                 if (r->user_name) {
5048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5051                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5052                 }
5053                 if (r->document_name) {
5054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5057                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5058                 }
5059                 if (r->notify_name) {
5060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5063                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5064                 }
5065                 if (r->data_type) {
5066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5069                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5070                 }
5071                 if (r->print_processor) {
5072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5075                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5076                 }
5077                 if (r->parameters) {
5078                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5081                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5082                 }
5083                 if (r->driver_name) {
5084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5087                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5088                 }
5089                 if (r->text_status) {
5090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5091                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5093                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5094                 }
5095         }
5096         return NDR_ERR_SUCCESS;
5097 }
5098
5099 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5100 {
5101         uint32_t _ptr_printer_name;
5102         TALLOC_CTX *_mem_save_printer_name_0;
5103         uint32_t _ptr_server_name;
5104         TALLOC_CTX *_mem_save_server_name_0;
5105         uint32_t _ptr_user_name;
5106         TALLOC_CTX *_mem_save_user_name_0;
5107         uint32_t _ptr_document_name;
5108         TALLOC_CTX *_mem_save_document_name_0;
5109         uint32_t _ptr_notify_name;
5110         TALLOC_CTX *_mem_save_notify_name_0;
5111         uint32_t _ptr_data_type;
5112         TALLOC_CTX *_mem_save_data_type_0;
5113         uint32_t _ptr_print_processor;
5114         TALLOC_CTX *_mem_save_print_processor_0;
5115         uint32_t _ptr_parameters;
5116         TALLOC_CTX *_mem_save_parameters_0;
5117         uint32_t _ptr_driver_name;
5118         TALLOC_CTX *_mem_save_driver_name_0;
5119         uint32_t _ptr_text_status;
5120         TALLOC_CTX *_mem_save_text_status_0;
5121         if (ndr_flags & NDR_SCALARS) {
5122                 NDR_CHECK(ndr_pull_align(ndr, 4));
5123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5125                 if (_ptr_printer_name) {
5126                         NDR_PULL_ALLOC(ndr, r->printer_name);
5127                 } else {
5128                         r->printer_name = NULL;
5129                 }
5130                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5131                 if (_ptr_server_name) {
5132                         NDR_PULL_ALLOC(ndr, r->server_name);
5133                 } else {
5134                         r->server_name = NULL;
5135                 }
5136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5137                 if (_ptr_user_name) {
5138                         NDR_PULL_ALLOC(ndr, r->user_name);
5139                 } else {
5140                         r->user_name = NULL;
5141                 }
5142                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5143                 if (_ptr_document_name) {
5144                         NDR_PULL_ALLOC(ndr, r->document_name);
5145                 } else {
5146                         r->document_name = NULL;
5147                 }
5148                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5149                 if (_ptr_notify_name) {
5150                         NDR_PULL_ALLOC(ndr, r->notify_name);
5151                 } else {
5152                         r->notify_name = NULL;
5153                 }
5154                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5155                 if (_ptr_data_type) {
5156                         NDR_PULL_ALLOC(ndr, r->data_type);
5157                 } else {
5158                         r->data_type = NULL;
5159                 }
5160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5161                 if (_ptr_print_processor) {
5162                         NDR_PULL_ALLOC(ndr, r->print_processor);
5163                 } else {
5164                         r->print_processor = NULL;
5165                 }
5166                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5167                 if (_ptr_parameters) {
5168                         NDR_PULL_ALLOC(ndr, r->parameters);
5169                 } else {
5170                         r->parameters = NULL;
5171                 }
5172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5173                 if (_ptr_driver_name) {
5174                         NDR_PULL_ALLOC(ndr, r->driver_name);
5175                 } else {
5176                         r->driver_name = NULL;
5177                 }
5178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5180                 if (_ptr_text_status) {
5181                         NDR_PULL_ALLOC(ndr, r->text_status);
5182                 } else {
5183                         r->text_status = NULL;
5184                 }
5185                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5186                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5188                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5193                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5194                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5195                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5197         }
5198         if (ndr_flags & NDR_BUFFERS) {
5199                 if (r->printer_name) {
5200                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5201                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5202                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5203                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5204                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5205                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5206                         }
5207                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5208                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5209                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5210                 }
5211                 if (r->server_name) {
5212                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5213                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5214                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5215                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5216                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5217                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5218                         }
5219                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5220                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5221                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5222                 }
5223                 if (r->user_name) {
5224                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5225                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5226                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5227                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5228                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5229                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5230                         }
5231                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5232                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5233                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5234                 }
5235                 if (r->document_name) {
5236                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5237                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5238                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5239                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5240                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5241                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5242                         }
5243                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5244                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5245                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5246                 }
5247                 if (r->notify_name) {
5248                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5249                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5250                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5251                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5252                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5253                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5254                         }
5255                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5256                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5257                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5258                 }
5259                 if (r->data_type) {
5260                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5261                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5262                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5263                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5264                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5265                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5266                         }
5267                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5268                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5269                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5270                 }
5271                 if (r->print_processor) {
5272                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5273                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5275                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5276                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5277                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5278                         }
5279                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5280                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5282                 }
5283                 if (r->parameters) {
5284                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5285                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5286                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5287                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5288                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5289                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5290                         }
5291                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5292                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5294                 }
5295                 if (r->driver_name) {
5296                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5297                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5298                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5299                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5300                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5301                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5302                         }
5303                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5304                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5305                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5306                 }
5307                 if (r->text_status) {
5308                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5309                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5310                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5311                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5312                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5313                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5314                         }
5315                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5316                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5317                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5318                 }
5319         }
5320         return NDR_ERR_SUCCESS;
5321 }
5322
5323 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5324 {
5325         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5326         ndr->depth++;
5327         ndr_print_uint32(ndr, "job_id", r->job_id);
5328         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5329         ndr->depth++;
5330         if (r->printer_name) {
5331                 ndr_print_string(ndr, "printer_name", r->printer_name);
5332         }
5333         ndr->depth--;
5334         ndr_print_ptr(ndr, "server_name", r->server_name);
5335         ndr->depth++;
5336         if (r->server_name) {
5337                 ndr_print_string(ndr, "server_name", r->server_name);
5338         }
5339         ndr->depth--;
5340         ndr_print_ptr(ndr, "user_name", r->user_name);
5341         ndr->depth++;
5342         if (r->user_name) {
5343                 ndr_print_string(ndr, "user_name", r->user_name);
5344         }
5345         ndr->depth--;
5346         ndr_print_ptr(ndr, "document_name", r->document_name);
5347         ndr->depth++;
5348         if (r->document_name) {
5349                 ndr_print_string(ndr, "document_name", r->document_name);
5350         }
5351         ndr->depth--;
5352         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5353         ndr->depth++;
5354         if (r->notify_name) {
5355                 ndr_print_string(ndr, "notify_name", r->notify_name);
5356         }
5357         ndr->depth--;
5358         ndr_print_ptr(ndr, "data_type", r->data_type);
5359         ndr->depth++;
5360         if (r->data_type) {
5361                 ndr_print_string(ndr, "data_type", r->data_type);
5362         }
5363         ndr->depth--;
5364         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5365         ndr->depth++;
5366         if (r->print_processor) {
5367                 ndr_print_string(ndr, "print_processor", r->print_processor);
5368         }
5369         ndr->depth--;
5370         ndr_print_ptr(ndr, "parameters", r->parameters);
5371         ndr->depth++;
5372         if (r->parameters) {
5373                 ndr_print_string(ndr, "parameters", r->parameters);
5374         }
5375         ndr->depth--;
5376         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5377         ndr->depth++;
5378         if (r->driver_name) {
5379                 ndr_print_string(ndr, "driver_name", r->driver_name);
5380         }
5381         ndr->depth--;
5382         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5383         ndr_print_ptr(ndr, "text_status", r->text_status);
5384         ndr->depth++;
5385         if (r->text_status) {
5386                 ndr_print_string(ndr, "text_status", r->text_status);
5387         }
5388         ndr->depth--;
5389         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5390         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5391         ndr_print_uint32(ndr, "priority", r->priority);
5392         ndr_print_uint32(ndr, "position", r->position);
5393         ndr_print_uint32(ndr, "start_time", r->start_time);
5394         ndr_print_uint32(ndr, "until_time", r->until_time);
5395         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5396         ndr_print_uint32(ndr, "size", r->size);
5397         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5398         ndr_print_uint32(ndr, "time", r->time);
5399         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5400         ndr_print_uint32(ndr, "size_high", r->size_high);
5401         ndr->depth--;
5402 }
5403
5404 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5405 {
5406         if (ndr_flags & NDR_SCALARS) {
5407                 int level = ndr_push_get_switch_value(ndr, r);
5408                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5409                 switch (level) {
5410                         case 1: {
5411                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5412                         break; }
5413
5414                         case 2: {
5415                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5416                         break; }
5417
5418                         case 3: {
5419                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5420                         break; }
5421
5422                         case 4: {
5423                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5424                         break; }
5425
5426                         default: {
5427                         break; }
5428
5429                 }
5430         }
5431         if (ndr_flags & NDR_BUFFERS) {
5432                 int level = ndr_push_get_switch_value(ndr, r);
5433                 switch (level) {
5434                         case 1:
5435                                 if (r->info1) {
5436                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5437                                 }
5438                         break;
5439
5440                         case 2:
5441                                 if (r->info2) {
5442                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5443                                 }
5444                         break;
5445
5446                         case 3:
5447                                 if (r->info3) {
5448                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5449                                 }
5450                         break;
5451
5452                         case 4:
5453                                 if (r->info4) {
5454                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5455                                 }
5456                         break;
5457
5458                         default:
5459                         break;
5460
5461                 }
5462         }
5463         return NDR_ERR_SUCCESS;
5464 }
5465
5466 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5467 {
5468         int level;
5469         uint32_t _level;
5470         TALLOC_CTX *_mem_save_info1_0;
5471         TALLOC_CTX *_mem_save_info2_0;
5472         TALLOC_CTX *_mem_save_info3_0;
5473         TALLOC_CTX *_mem_save_info4_0;
5474         level = ndr_pull_get_switch_value(ndr, r);
5475         if (ndr_flags & NDR_SCALARS) {
5476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5477                 if (_level != level) {
5478                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5479                 }
5480                 switch (level) {
5481                         case 1: {
5482                                 uint32_t _ptr_info1;
5483                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5484                                 if (_ptr_info1) {
5485                                         NDR_PULL_ALLOC(ndr, r->info1);
5486                                 } else {
5487                                         r->info1 = NULL;
5488                                 }
5489                         break; }
5490
5491                         case 2: {
5492                                 uint32_t _ptr_info2;
5493                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5494                                 if (_ptr_info2) {
5495                                         NDR_PULL_ALLOC(ndr, r->info2);
5496                                 } else {
5497                                         r->info2 = NULL;
5498                                 }
5499                         break; }
5500
5501                         case 3: {
5502                                 uint32_t _ptr_info3;
5503                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5504                                 if (_ptr_info3) {
5505                                         NDR_PULL_ALLOC(ndr, r->info3);
5506                                 } else {
5507                                         r->info3 = NULL;
5508                                 }
5509                         break; }
5510
5511                         case 4: {
5512                                 uint32_t _ptr_info4;
5513                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5514                                 if (_ptr_info4) {
5515                                         NDR_PULL_ALLOC(ndr, r->info4);
5516                                 } else {
5517                                         r->info4 = NULL;
5518                                 }
5519                         break; }
5520
5521                         default: {
5522                         break; }
5523
5524                 }
5525         }
5526         if (ndr_flags & NDR_BUFFERS) {
5527                 switch (level) {
5528                         case 1:
5529                                 if (r->info1) {
5530                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5531                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5532                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5533                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5534                                 }
5535                         break;
5536
5537                         case 2:
5538                                 if (r->info2) {
5539                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5540                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5541                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5542                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5543                                 }
5544                         break;
5545
5546                         case 3:
5547                                 if (r->info3) {
5548                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5549                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5550                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5551                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5552                                 }
5553                         break;
5554
5555                         case 4:
5556                                 if (r->info4) {
5557                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5558                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5559                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5560                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5561                                 }
5562                         break;
5563
5564                         default:
5565                         break;
5566
5567                 }
5568         }
5569         return NDR_ERR_SUCCESS;
5570 }
5571
5572 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5573 {
5574         int level;
5575         level = ndr_print_get_switch_value(ndr, r);
5576         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5577         switch (level) {
5578                 case 1:
5579                         ndr_print_ptr(ndr, "info1", r->info1);
5580                         ndr->depth++;
5581                         if (r->info1) {
5582                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5583                         }
5584                         ndr->depth--;
5585                 break;
5586
5587                 case 2:
5588                         ndr_print_ptr(ndr, "info2", r->info2);
5589                         ndr->depth++;
5590                         if (r->info2) {
5591                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5592                         }
5593                         ndr->depth--;
5594                 break;
5595
5596                 case 3:
5597                         ndr_print_ptr(ndr, "info3", r->info3);
5598                         ndr->depth++;
5599                         if (r->info3) {
5600                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5601                         }
5602                         ndr->depth--;
5603                 break;
5604
5605                 case 4:
5606                         ndr_print_ptr(ndr, "info4", r->info4);
5607                         ndr->depth++;
5608                         if (r->info4) {
5609                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5610                         }
5611                         ndr->depth--;
5612                 break;
5613
5614                 default:
5615                 break;
5616
5617         }
5618 }
5619
5620 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5621 {
5622         if (ndr_flags & NDR_SCALARS) {
5623                 NDR_CHECK(ndr_push_align(ndr, 4));
5624                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5625                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5626                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5627         }
5628         if (ndr_flags & NDR_BUFFERS) {
5629                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5630         }
5631         return NDR_ERR_SUCCESS;
5632 }
5633
5634 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5635 {
5636         if (ndr_flags & NDR_SCALARS) {
5637                 NDR_CHECK(ndr_pull_align(ndr, 4));
5638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5639                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5640                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5641         }
5642         if (ndr_flags & NDR_BUFFERS) {
5643                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5644         }
5645         return NDR_ERR_SUCCESS;
5646 }
5647
5648 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5649 {
5650         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5651         ndr->depth++;
5652         ndr_print_uint32(ndr, "level", r->level);
5653         ndr_print_set_switch_value(ndr, &r->info, r->level);
5654         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5655         ndr->depth--;
5656 }
5657
5658 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5659 {
5660         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5661         return NDR_ERR_SUCCESS;
5662 }
5663
5664 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5665 {
5666         uint32_t v;
5667         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5668         *r = v;
5669         return NDR_ERR_SUCCESS;
5670 }
5671
5672 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5673 {
5674         const char *val = NULL;
5675
5676         switch (r) {
5677                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5678                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5679                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5680                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5681                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5682                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5683                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5684                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5685                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5686         }
5687         ndr_print_enum(ndr, name, "ENUM", val, r);
5688 }
5689
5690 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5691 {
5692         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5693         return NDR_ERR_SUCCESS;
5694 }
5695
5696 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5697 {
5698         uint32_t v;
5699         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5700         *r = v;
5701         return NDR_ERR_SUCCESS;
5702 }
5703
5704 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5705 {
5706         const char *val = NULL;
5707
5708         switch (r) {
5709                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5710                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5711                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5712                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5713                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5714         }
5715         ndr_print_enum(ndr, name, "ENUM", val, r);
5716 }
5717
5718 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5719 {
5720         if (ndr_flags & NDR_SCALARS) {
5721                 NDR_CHECK(ndr_push_align(ndr, 4));
5722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5727                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5738                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5739                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5742                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5746                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5747                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5751         }
5752         if (ndr_flags & NDR_BUFFERS) {
5753                 if (r->servername) {
5754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5757                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5758                 }
5759                 if (r->printername) {
5760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5761                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5764                 }
5765         }
5766         return NDR_ERR_SUCCESS;
5767 }
5768
5769 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5770 {
5771         uint32_t _ptr_servername;
5772         TALLOC_CTX *_mem_save_servername_0;
5773         uint32_t _ptr_printername;
5774         TALLOC_CTX *_mem_save_printername_0;
5775         if (ndr_flags & NDR_SCALARS) {
5776                 NDR_CHECK(ndr_pull_align(ndr, 4));
5777                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5778                 if (_ptr_servername) {
5779                         NDR_PULL_ALLOC(ndr, r->servername);
5780                 } else {
5781                         r->servername = NULL;
5782                 }
5783                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5784                 if (_ptr_printername) {
5785                         NDR_PULL_ALLOC(ndr, r->printername);
5786                 } else {
5787                         r->printername = NULL;
5788                 }
5789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5792                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5794                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5798                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5799                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5801                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5803                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5804                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5807                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5811                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5812                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5813                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5814                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5815                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5816         }
5817         if (ndr_flags & NDR_BUFFERS) {
5818                 if (r->servername) {
5819                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5820                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5821                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5822                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5823                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5824                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
5825                         }
5826                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5827                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5829                 }
5830                 if (r->printername) {
5831                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5832                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5833                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5834                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5835                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5836                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
5837                         }
5838                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5839                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5841                 }
5842         }
5843         return NDR_ERR_SUCCESS;
5844 }
5845
5846 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5847 {
5848         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5849         ndr->depth++;
5850         ndr_print_ptr(ndr, "servername", r->servername);
5851         ndr->depth++;
5852         if (r->servername) {
5853                 ndr_print_string(ndr, "servername", r->servername);
5854         }
5855         ndr->depth--;
5856         ndr_print_ptr(ndr, "printername", r->printername);
5857         ndr->depth++;
5858         if (r->printername) {
5859                 ndr_print_string(ndr, "printername", r->printername);
5860         }
5861         ndr->depth--;
5862         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5863         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5864         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5865         ndr_print_spoolss_Time(ndr, "time", &r->time);
5866         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5867         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5868         ndr_print_uint32(ndr, "version", r->version);
5869         ndr_print_uint32(ndr, "free_build", r->free_build);
5870         ndr_print_uint32(ndr, "spooling", r->spooling);
5871         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5872         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5873         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5874         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5875         ndr_print_uint32(ndr, "job_error", r->job_error);
5876         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5877         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5878         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5879         ndr_print_uint32(ndr, "change_id", r->change_id);
5880         ndr_print_WERROR(ndr, "last_error", r->last_error);
5881         ndr_print_uint32(ndr, "status", r->status);
5882         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5883         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5884         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5885         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5886         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5887         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5888         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5889         ndr->depth--;
5890 }
5891
5892 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5893 {
5894         if (ndr_flags & NDR_SCALARS) {
5895                 NDR_CHECK(ndr_push_align(ndr, 4));
5896                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5900         }
5901         if (ndr_flags & NDR_BUFFERS) {
5902                 if (r->name) {
5903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5907                 }
5908                 if (r->description) {
5909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5913                 }
5914                 if (r->comment) {
5915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5919                 }
5920         }
5921         return NDR_ERR_SUCCESS;
5922 }
5923
5924 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5925 {
5926         uint32_t _ptr_name;
5927         TALLOC_CTX *_mem_save_name_0;
5928         uint32_t _ptr_description;
5929         TALLOC_CTX *_mem_save_description_0;
5930         uint32_t _ptr_comment;
5931         TALLOC_CTX *_mem_save_comment_0;
5932         if (ndr_flags & NDR_SCALARS) {
5933                 NDR_CHECK(ndr_pull_align(ndr, 4));
5934                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
5935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
5936                 if (_ptr_name) {
5937                         NDR_PULL_ALLOC(ndr, r->name);
5938                 } else {
5939                         r->name = NULL;
5940                 }
5941                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
5942                 if (_ptr_description) {
5943                         NDR_PULL_ALLOC(ndr, r->description);
5944                 } else {
5945                         r->description = NULL;
5946                 }
5947                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
5948                 if (_ptr_comment) {
5949                         NDR_PULL_ALLOC(ndr, r->comment);
5950                 } else {
5951                         r->comment = NULL;
5952                 }
5953         }
5954         if (ndr_flags & NDR_BUFFERS) {
5955                 if (r->name) {
5956                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5957                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
5958                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
5959                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
5960                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
5961                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
5962                         }
5963                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
5964                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
5965                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
5966                 }
5967                 if (r->description) {
5968                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
5969                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
5970                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
5971                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
5972                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
5973                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
5974                         }
5975                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
5976                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
5977                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
5978                 }
5979                 if (r->comment) {
5980                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
5981                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
5982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
5983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
5984                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
5985                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
5986                         }
5987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
5988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
5989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
5990                 }
5991         }
5992         return NDR_ERR_SUCCESS;
5993 }
5994
5995 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
5996 {
5997         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
5998         ndr->depth++;
5999         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
6000         ndr_print_ptr(ndr, "name", r->name);
6001         ndr->depth++;
6002         if (r->name) {
6003                 ndr_print_string(ndr, "name", r->name);
6004         }
6005         ndr->depth--;
6006         ndr_print_ptr(ndr, "description", r->description);
6007         ndr->depth++;
6008         if (r->description) {
6009                 ndr_print_string(ndr, "description", r->description);
6010         }
6011         ndr->depth--;
6012         ndr_print_ptr(ndr, "comment", r->comment);
6013         ndr->depth++;
6014         if (r->comment) {
6015                 ndr_print_string(ndr, "comment", r->comment);
6016         }
6017         ndr->depth--;
6018         ndr->depth--;
6019 }
6020
6021 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6022 {
6023         if (ndr_flags & NDR_SCALARS) {
6024                 NDR_CHECK(ndr_push_align(ndr, 4));
6025                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6026                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6027                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6028                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6030                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6038                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6043                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6046         }
6047         if (ndr_flags & NDR_BUFFERS) {
6048                 if (r->servername) {
6049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6050                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6051                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6052                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6053                 }
6054                 if (r->printername) {
6055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6058                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6059                 }
6060                 if (r->sharename) {
6061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6064                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6065                 }
6066                 if (r->portname) {
6067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6070                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6071                 }
6072                 if (r->drivername) {
6073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6076                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6077                 }
6078                 if (r->comment) {
6079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6082                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6083                 }
6084                 if (r->location) {
6085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6088                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6089                 }
6090                 if (r->devmode) {
6091                         {
6092                                 struct ndr_push *_ndr_devmode;
6093                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6094                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6095                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6096                         }
6097                 }
6098                 if (r->sepfile) {
6099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6103                 }
6104                 if (r->printprocessor) {
6105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6109                 }
6110                 if (r->datatype) {
6111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6115                 }
6116                 if (r->parameters) {
6117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6121                 }
6122                 if (r->secdesc) {
6123                         {
6124                                 struct ndr_push *_ndr_secdesc;
6125                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6126                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6127                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6128                         }
6129                 }
6130         }
6131         return NDR_ERR_SUCCESS;
6132 }
6133
6134 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6135 {
6136         uint32_t _ptr_servername;
6137         TALLOC_CTX *_mem_save_servername_0;
6138         uint32_t _ptr_printername;
6139         TALLOC_CTX *_mem_save_printername_0;
6140         uint32_t _ptr_sharename;
6141         TALLOC_CTX *_mem_save_sharename_0;
6142         uint32_t _ptr_portname;
6143         TALLOC_CTX *_mem_save_portname_0;
6144         uint32_t _ptr_drivername;
6145         TALLOC_CTX *_mem_save_drivername_0;
6146         uint32_t _ptr_comment;
6147         TALLOC_CTX *_mem_save_comment_0;
6148         uint32_t _ptr_location;
6149         TALLOC_CTX *_mem_save_location_0;
6150         uint32_t _ptr_devmode;
6151         TALLOC_CTX *_mem_save_devmode_0;
6152         uint32_t _ptr_sepfile;
6153         TALLOC_CTX *_mem_save_sepfile_0;
6154         uint32_t _ptr_printprocessor;
6155         TALLOC_CTX *_mem_save_printprocessor_0;
6156         uint32_t _ptr_datatype;
6157         TALLOC_CTX *_mem_save_datatype_0;
6158         uint32_t _ptr_parameters;
6159         TALLOC_CTX *_mem_save_parameters_0;
6160         uint32_t _ptr_secdesc;
6161         TALLOC_CTX *_mem_save_secdesc_0;
6162         if (ndr_flags & NDR_SCALARS) {
6163                 NDR_CHECK(ndr_pull_align(ndr, 4));
6164                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6165                 if (_ptr_servername) {
6166                         NDR_PULL_ALLOC(ndr, r->servername);
6167                 } else {
6168                         r->servername = NULL;
6169                 }
6170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6171                 if (_ptr_printername) {
6172                         NDR_PULL_ALLOC(ndr, r->printername);
6173                 } else {
6174                         r->printername = NULL;
6175                 }
6176                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6177                 if (_ptr_sharename) {
6178                         NDR_PULL_ALLOC(ndr, r->sharename);
6179                 } else {
6180                         r->sharename = NULL;
6181                 }
6182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6183                 if (_ptr_portname) {
6184                         NDR_PULL_ALLOC(ndr, r->portname);
6185                 } else {
6186                         r->portname = NULL;
6187                 }
6188                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6189                 if (_ptr_drivername) {
6190                         NDR_PULL_ALLOC(ndr, r->drivername);
6191                 } else {
6192                         r->drivername = NULL;
6193                 }
6194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6195                 if (_ptr_comment) {
6196                         NDR_PULL_ALLOC(ndr, r->comment);
6197                 } else {
6198                         r->comment = NULL;
6199                 }
6200                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6201                 if (_ptr_location) {
6202                         NDR_PULL_ALLOC(ndr, r->location);
6203                 } else {
6204                         r->location = NULL;
6205                 }
6206                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6207                 if (_ptr_devmode) {
6208                         NDR_PULL_ALLOC(ndr, r->devmode);
6209                 } else {
6210                         r->devmode = NULL;
6211                 }
6212                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6213                 if (_ptr_sepfile) {
6214                         NDR_PULL_ALLOC(ndr, r->sepfile);
6215                 } else {
6216                         r->sepfile = NULL;
6217                 }
6218                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6219                 if (_ptr_printprocessor) {
6220                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6221                 } else {
6222                         r->printprocessor = NULL;
6223                 }
6224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6225                 if (_ptr_datatype) {
6226                         NDR_PULL_ALLOC(ndr, r->datatype);
6227                 } else {
6228                         r->datatype = NULL;
6229                 }
6230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6231                 if (_ptr_parameters) {
6232                         NDR_PULL_ALLOC(ndr, r->parameters);
6233                 } else {
6234                         r->parameters = NULL;
6235                 }
6236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6237                 if (_ptr_secdesc) {
6238                         NDR_PULL_ALLOC(ndr, r->secdesc);
6239                 } else {
6240                         r->secdesc = NULL;
6241                 }
6242                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6243                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6246                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6247                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6249                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6250         }
6251         if (ndr_flags & NDR_BUFFERS) {
6252                 if (r->servername) {
6253                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6254                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6255                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6256                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6257                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6258                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6259                         }
6260                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6261                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6263                 }
6264                 if (r->printername) {
6265                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6266                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6267                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6268                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6269                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6270                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6271                         }
6272                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6275                 }
6276                 if (r->sharename) {
6277                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6278                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6280                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6281                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6282                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
6283                         }
6284                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6285                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6287                 }
6288                 if (r->portname) {
6289                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6290                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6291                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6292                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6293                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6294                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6295                         }
6296                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6297                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6299                 }
6300                 if (r->drivername) {
6301                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6302                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6303                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6304                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6305                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6306                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
6307                         }
6308                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6309                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6311                 }
6312                 if (r->comment) {
6313                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6314                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6317                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6318                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6319                         }
6320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6323                 }
6324                 if (r->location) {
6325                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6326                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6329                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6330                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
6331                         }
6332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6333                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6335                 }
6336                 if (r->devmode) {
6337                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6338                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6339                         {
6340                                 struct ndr_pull *_ndr_devmode;
6341                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6342                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6343                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6344                         }
6345                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6346                 }
6347                 if (r->sepfile) {
6348                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6349                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6350                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6351                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6352                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6353                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
6354                         }
6355                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6356                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6357                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6358                 }
6359                 if (r->printprocessor) {
6360                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6361                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6364                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6365                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
6366                         }
6367                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6368                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6370                 }
6371                 if (r->datatype) {
6372                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6373                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6374                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6375                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6376                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6377                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
6378                         }
6379                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6380                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6381                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6382                 }
6383                 if (r->parameters) {
6384                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6385                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6386                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6387                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6388                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6389                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
6390                         }
6391                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6392                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6393                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6394                 }
6395                 if (r->secdesc) {
6396                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6397                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6398                         {
6399                                 struct ndr_pull *_ndr_secdesc;
6400                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6401                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6402                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6403                         }
6404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6405                 }
6406         }
6407         return NDR_ERR_SUCCESS;
6408 }
6409
6410 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6411 {
6412         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6413         ndr->depth++;
6414         ndr_print_ptr(ndr, "servername", r->servername);
6415         ndr->depth++;
6416         if (r->servername) {
6417                 ndr_print_string(ndr, "servername", r->servername);
6418         }
6419         ndr->depth--;
6420         ndr_print_ptr(ndr, "printername", r->printername);
6421         ndr->depth++;
6422         if (r->printername) {
6423                 ndr_print_string(ndr, "printername", r->printername);
6424         }
6425         ndr->depth--;
6426         ndr_print_ptr(ndr, "sharename", r->sharename);
6427         ndr->depth++;
6428         if (r->sharename) {
6429                 ndr_print_string(ndr, "sharename", r->sharename);
6430         }
6431         ndr->depth--;
6432         ndr_print_ptr(ndr, "portname", r->portname);
6433         ndr->depth++;
6434         if (r->portname) {
6435                 ndr_print_string(ndr, "portname", r->portname);
6436         }
6437         ndr->depth--;
6438         ndr_print_ptr(ndr, "drivername", r->drivername);
6439         ndr->depth++;
6440         if (r->drivername) {
6441                 ndr_print_string(ndr, "drivername", r->drivername);
6442         }
6443         ndr->depth--;
6444         ndr_print_ptr(ndr, "comment", r->comment);
6445         ndr->depth++;
6446         if (r->comment) {
6447                 ndr_print_string(ndr, "comment", r->comment);
6448         }
6449         ndr->depth--;
6450         ndr_print_ptr(ndr, "location", r->location);
6451         ndr->depth++;
6452         if (r->location) {
6453                 ndr_print_string(ndr, "location", r->location);
6454         }
6455         ndr->depth--;
6456         ndr_print_ptr(ndr, "devmode", r->devmode);
6457         ndr->depth++;
6458         if (r->devmode) {
6459                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6460         }
6461         ndr->depth--;
6462         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6463         ndr->depth++;
6464         if (r->sepfile) {
6465                 ndr_print_string(ndr, "sepfile", r->sepfile);
6466         }
6467         ndr->depth--;
6468         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6469         ndr->depth++;
6470         if (r->printprocessor) {
6471                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6472         }
6473         ndr->depth--;
6474         ndr_print_ptr(ndr, "datatype", r->datatype);
6475         ndr->depth++;
6476         if (r->datatype) {
6477                 ndr_print_string(ndr, "datatype", r->datatype);
6478         }
6479         ndr->depth--;
6480         ndr_print_ptr(ndr, "parameters", r->parameters);
6481         ndr->depth++;
6482         if (r->parameters) {
6483                 ndr_print_string(ndr, "parameters", r->parameters);
6484         }
6485         ndr->depth--;
6486         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6487         ndr->depth++;
6488         if (r->secdesc) {
6489                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6490         }
6491         ndr->depth--;
6492         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6493         ndr_print_uint32(ndr, "priority", r->priority);
6494         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6495         ndr_print_uint32(ndr, "starttime", r->starttime);
6496         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6497         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6498         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6499         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6500         ndr->depth--;
6501 }
6502
6503 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6504 {
6505         if (ndr_flags & NDR_SCALARS) {
6506                 NDR_CHECK(ndr_push_align(ndr, 4));
6507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6508         }
6509         if (ndr_flags & NDR_BUFFERS) {
6510         }
6511         return NDR_ERR_SUCCESS;
6512 }
6513
6514 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6515 {
6516         if (ndr_flags & NDR_SCALARS) {
6517                 NDR_CHECK(ndr_pull_align(ndr, 4));
6518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6519         }
6520         if (ndr_flags & NDR_BUFFERS) {
6521         }
6522         return NDR_ERR_SUCCESS;
6523 }
6524
6525 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6526 {
6527         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6528         ndr->depth++;
6529         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6530         ndr->depth--;
6531 }
6532
6533 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6534 {
6535         if (ndr_flags & NDR_SCALARS) {
6536                 NDR_CHECK(ndr_push_align(ndr, 4));
6537                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6538                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6539                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6540         }
6541         if (ndr_flags & NDR_BUFFERS) {
6542                 if (r->printername) {
6543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6545                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6546                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6547                 }
6548                 if (r->servername) {
6549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6551                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6552                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6553                 }
6554         }
6555         return NDR_ERR_SUCCESS;
6556 }
6557
6558 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6559 {
6560         uint32_t _ptr_printername;
6561         TALLOC_CTX *_mem_save_printername_0;
6562         uint32_t _ptr_servername;
6563         TALLOC_CTX *_mem_save_servername_0;
6564         if (ndr_flags & NDR_SCALARS) {
6565                 NDR_CHECK(ndr_pull_align(ndr, 4));
6566                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6567                 if (_ptr_printername) {
6568                         NDR_PULL_ALLOC(ndr, r->printername);
6569                 } else {
6570                         r->printername = NULL;
6571                 }
6572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6573                 if (_ptr_servername) {
6574                         NDR_PULL_ALLOC(ndr, r->servername);
6575                 } else {
6576                         r->servername = NULL;
6577                 }
6578                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6579         }
6580         if (ndr_flags & NDR_BUFFERS) {
6581                 if (r->printername) {
6582                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6583                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6584                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6585                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6586                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6587                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6588                         }
6589                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6590                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6592                 }
6593                 if (r->servername) {
6594                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6595                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6596                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6597                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6598                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6599                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6600                         }
6601                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6602                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6603                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6604                 }
6605         }
6606         return NDR_ERR_SUCCESS;
6607 }
6608
6609 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6610 {
6611         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6612         ndr->depth++;
6613         ndr_print_ptr(ndr, "printername", r->printername);
6614         ndr->depth++;
6615         if (r->printername) {
6616                 ndr_print_string(ndr, "printername", r->printername);
6617         }
6618         ndr->depth--;
6619         ndr_print_ptr(ndr, "servername", r->servername);
6620         ndr->depth++;
6621         if (r->servername) {
6622                 ndr_print_string(ndr, "servername", r->servername);
6623         }
6624         ndr->depth--;
6625         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6626         ndr->depth--;
6627 }
6628
6629 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6630 {
6631         if (ndr_flags & NDR_SCALARS) {
6632                 NDR_CHECK(ndr_push_align(ndr, 4));
6633                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6634                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6635                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6638         }
6639         if (ndr_flags & NDR_BUFFERS) {
6640                 if (r->printername) {
6641                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6642                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6643                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6644                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6645                 }
6646                 if (r->portname) {
6647                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6648                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6649                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6650                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6651                 }
6652         }
6653         return NDR_ERR_SUCCESS;
6654 }
6655
6656 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6657 {
6658         uint32_t _ptr_printername;
6659         TALLOC_CTX *_mem_save_printername_0;
6660         uint32_t _ptr_portname;
6661         TALLOC_CTX *_mem_save_portname_0;
6662         if (ndr_flags & NDR_SCALARS) {
6663                 NDR_CHECK(ndr_pull_align(ndr, 4));
6664                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6665                 if (_ptr_printername) {
6666                         NDR_PULL_ALLOC(ndr, r->printername);
6667                 } else {
6668                         r->printername = NULL;
6669                 }
6670                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6671                 if (_ptr_portname) {
6672                         NDR_PULL_ALLOC(ndr, r->portname);
6673                 } else {
6674                         r->portname = NULL;
6675                 }
6676                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6679         }
6680         if (ndr_flags & NDR_BUFFERS) {
6681                 if (r->printername) {
6682                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6683                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6684                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6685                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6686                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6687                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6688                         }
6689                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6690                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6691                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6692                 }
6693                 if (r->portname) {
6694                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6695                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6696                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6697                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6698                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6699                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6700                         }
6701                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6702                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6703                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6704                 }
6705         }
6706         return NDR_ERR_SUCCESS;
6707 }
6708
6709 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6710 {
6711         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6712         ndr->depth++;
6713         ndr_print_ptr(ndr, "printername", r->printername);
6714         ndr->depth++;
6715         if (r->printername) {
6716                 ndr_print_string(ndr, "printername", r->printername);
6717         }
6718         ndr->depth--;
6719         ndr_print_ptr(ndr, "portname", r->portname);
6720         ndr->depth++;
6721         if (r->portname) {
6722                 ndr_print_string(ndr, "portname", r->portname);
6723         }
6724         ndr->depth--;
6725         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6726         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6727         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6728         ndr->depth--;
6729 }
6730
6731 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6732 {
6733         if (ndr_flags & NDR_SCALARS) {
6734                 NDR_CHECK(ndr_push_align(ndr, 4));
6735                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6736         }
6737         if (ndr_flags & NDR_BUFFERS) {
6738         }
6739         return NDR_ERR_SUCCESS;
6740 }
6741
6742 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6743 {
6744         if (ndr_flags & NDR_SCALARS) {
6745                 NDR_CHECK(ndr_pull_align(ndr, 4));
6746                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6747         }
6748         if (ndr_flags & NDR_BUFFERS) {
6749         }
6750         return NDR_ERR_SUCCESS;
6751 }
6752
6753 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6754 {
6755         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6756         ndr->depth++;
6757         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6758         ndr->depth--;
6759 }
6760
6761 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6762 {
6763         if (ndr_flags & NDR_SCALARS) {
6764                 NDR_CHECK(ndr_push_align(ndr, 4));
6765                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6766                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6767         }
6768         if (ndr_flags & NDR_BUFFERS) {
6769                 if (r->guid) {
6770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6772                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6773                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6774                 }
6775         }
6776         return NDR_ERR_SUCCESS;
6777 }
6778
6779 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6780 {
6781         uint32_t _ptr_guid;
6782         TALLOC_CTX *_mem_save_guid_0;
6783         if (ndr_flags & NDR_SCALARS) {
6784                 NDR_CHECK(ndr_pull_align(ndr, 4));
6785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6786                 if (_ptr_guid) {
6787                         NDR_PULL_ALLOC(ndr, r->guid);
6788                 } else {
6789                         r->guid = NULL;
6790                 }
6791                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6792         }
6793         if (ndr_flags & NDR_BUFFERS) {
6794                 if (r->guid) {
6795                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6796                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6797                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6798                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6799                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6800                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
6801                         }
6802                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6803                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6804                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6805                 }
6806         }
6807         return NDR_ERR_SUCCESS;
6808 }
6809
6810 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6811 {
6812         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6813         ndr->depth++;
6814         ndr_print_ptr(ndr, "guid", r->guid);
6815         ndr->depth++;
6816         if (r->guid) {
6817                 ndr_print_string(ndr, "guid", r->guid);
6818         }
6819         ndr->depth--;
6820         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6821         ndr->depth--;
6822 }
6823
6824 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6825 {
6826         if (ndr_flags & NDR_SCALARS) {
6827                 int level = ndr_push_get_switch_value(ndr, r);
6828                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6829                 switch (level) {
6830                         case 0: {
6831                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6832                         break; }
6833
6834                         case 1: {
6835                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6836                         break; }
6837
6838                         case 2: {
6839                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6840                         break; }
6841
6842                         case 3: {
6843                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6844                         break; }
6845
6846                         case 4: {
6847                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6848                         break; }
6849
6850                         case 5: {
6851                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6852                         break; }
6853
6854                         case 6: {
6855                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6856                         break; }
6857
6858                         case 7: {
6859                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6860                         break; }
6861
6862                         case 8: {
6863                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6864                         break; }
6865
6866                         case 9: {
6867                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6868                         break; }
6869
6870                         default: {
6871                         break; }
6872
6873                 }
6874         }
6875         if (ndr_flags & NDR_BUFFERS) {
6876                 int level = ndr_push_get_switch_value(ndr, r);
6877                 switch (level) {
6878                         case 0:
6879                                 if (r->info0) {
6880                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6881                                 }
6882                         break;
6883
6884                         case 1:
6885                                 if (r->info1) {
6886                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6887                                 }
6888                         break;
6889
6890                         case 2:
6891                                 if (r->info2) {
6892                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6893                                 }
6894                         break;
6895
6896                         case 3:
6897                                 if (r->info3) {
6898                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6899                                 }
6900                         break;
6901
6902                         case 4:
6903                                 if (r->info4) {
6904                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6905                                 }
6906                         break;
6907
6908                         case 5:
6909                                 if (r->info5) {
6910                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6911                                 }
6912                         break;
6913
6914                         case 6:
6915                                 if (r->info6) {
6916                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6917                                 }
6918                         break;
6919
6920                         case 7:
6921                                 if (r->info7) {
6922                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6923                                 }
6924                         break;
6925
6926                         case 8:
6927                                 if (r->info8) {
6928                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6929                                 }
6930                         break;
6931
6932                         case 9:
6933                                 if (r->info9) {
6934                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
6935                                 }
6936                         break;
6937
6938                         default:
6939                         break;
6940
6941                 }
6942         }
6943         return NDR_ERR_SUCCESS;
6944 }
6945
6946 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
6947 {
6948         int level;
6949         uint32_t _level;
6950         TALLOC_CTX *_mem_save_info0_0;
6951         TALLOC_CTX *_mem_save_info1_0;
6952         TALLOC_CTX *_mem_save_info2_0;
6953         TALLOC_CTX *_mem_save_info3_0;
6954         TALLOC_CTX *_mem_save_info4_0;
6955         TALLOC_CTX *_mem_save_info5_0;
6956         TALLOC_CTX *_mem_save_info6_0;
6957         TALLOC_CTX *_mem_save_info7_0;
6958         TALLOC_CTX *_mem_save_info8_0;
6959         TALLOC_CTX *_mem_save_info9_0;
6960         level = ndr_pull_get_switch_value(ndr, r);
6961         if (ndr_flags & NDR_SCALARS) {
6962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
6963                 if (_level != level) {
6964                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
6965                 }
6966                 switch (level) {
6967                         case 0: {
6968                                 uint32_t _ptr_info0;
6969                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
6970                                 if (_ptr_info0) {
6971                                         NDR_PULL_ALLOC(ndr, r->info0);
6972                                 } else {
6973                                         r->info0 = NULL;
6974                                 }
6975                         break; }
6976
6977                         case 1: {
6978                                 uint32_t _ptr_info1;
6979                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
6980                                 if (_ptr_info1) {
6981                                         NDR_PULL_ALLOC(ndr, r->info1);
6982                                 } else {
6983                                         r->info1 = NULL;
6984                                 }
6985                         break; }
6986
6987                         case 2: {
6988                                 uint32_t _ptr_info2;
6989                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
6990                                 if (_ptr_info2) {
6991                                         NDR_PULL_ALLOC(ndr, r->info2);
6992                                 } else {
6993                                         r->info2 = NULL;
6994                                 }
6995                         break; }
6996
6997                         case 3: {
6998                                 uint32_t _ptr_info3;
6999                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7000                                 if (_ptr_info3) {
7001                                         NDR_PULL_ALLOC(ndr, r->info3);
7002                                 } else {
7003                                         r->info3 = NULL;
7004                                 }
7005                         break; }
7006
7007                         case 4: {
7008                                 uint32_t _ptr_info4;
7009                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7010                                 if (_ptr_info4) {
7011                                         NDR_PULL_ALLOC(ndr, r->info4);
7012                                 } else {
7013                                         r->info4 = NULL;
7014                                 }
7015                         break; }
7016
7017                         case 5: {
7018                                 uint32_t _ptr_info5;
7019                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7020                                 if (_ptr_info5) {
7021                                         NDR_PULL_ALLOC(ndr, r->info5);
7022                                 } else {
7023                                         r->info5 = NULL;
7024                                 }
7025                         break; }
7026
7027                         case 6: {
7028                                 uint32_t _ptr_info6;
7029                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7030                                 if (_ptr_info6) {
7031                                         NDR_PULL_ALLOC(ndr, r->info6);
7032                                 } else {
7033                                         r->info6 = NULL;
7034                                 }
7035                         break; }
7036
7037                         case 7: {
7038                                 uint32_t _ptr_info7;
7039                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7040                                 if (_ptr_info7) {
7041                                         NDR_PULL_ALLOC(ndr, r->info7);
7042                                 } else {
7043                                         r->info7 = NULL;
7044                                 }
7045                         break; }
7046
7047                         case 8: {
7048                                 uint32_t _ptr_info8;
7049                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7050                                 if (_ptr_info8) {
7051                                         NDR_PULL_ALLOC(ndr, r->info8);
7052                                 } else {
7053                                         r->info8 = NULL;
7054                                 }
7055                         break; }
7056
7057                         case 9: {
7058                                 uint32_t _ptr_info9;
7059                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7060                                 if (_ptr_info9) {
7061                                         NDR_PULL_ALLOC(ndr, r->info9);
7062                                 } else {
7063                                         r->info9 = NULL;
7064                                 }
7065                         break; }
7066
7067                         default: {
7068                         break; }
7069
7070                 }
7071         }
7072         if (ndr_flags & NDR_BUFFERS) {
7073                 switch (level) {
7074                         case 0:
7075                                 if (r->info0) {
7076                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7077                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7078                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7079                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7080                                 }
7081                         break;
7082
7083                         case 1:
7084                                 if (r->info1) {
7085                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7086                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7087                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7088                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7089                                 }
7090                         break;
7091
7092                         case 2:
7093                                 if (r->info2) {
7094                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7095                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7096                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7097                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7098                                 }
7099                         break;
7100
7101                         case 3:
7102                                 if (r->info3) {
7103                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7104                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7105                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7106                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7107                                 }
7108                         break;
7109
7110                         case 4:
7111                                 if (r->info4) {
7112                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7113                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7114                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7115                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7116                                 }
7117                         break;
7118
7119                         case 5:
7120                                 if (r->info5) {
7121                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7122                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7123                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7124                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7125                                 }
7126                         break;
7127
7128                         case 6:
7129                                 if (r->info6) {
7130                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7131                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7132                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7133                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7134                                 }
7135                         break;
7136
7137                         case 7:
7138                                 if (r->info7) {
7139                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7140                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7141                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7142                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7143                                 }
7144                         break;
7145
7146                         case 8:
7147                                 if (r->info8) {
7148                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7149                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7150                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7151                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7152                                 }
7153                         break;
7154
7155                         case 9:
7156                                 if (r->info9) {
7157                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7158                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7159                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7160                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7161                                 }
7162                         break;
7163
7164                         default:
7165                         break;
7166
7167                 }
7168         }
7169         return NDR_ERR_SUCCESS;
7170 }
7171
7172 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7173 {
7174         int level;
7175         level = ndr_print_get_switch_value(ndr, r);
7176         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7177         switch (level) {
7178                 case 0:
7179                         ndr_print_ptr(ndr, "info0", r->info0);
7180                         ndr->depth++;
7181                         if (r->info0) {
7182                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7183                         }
7184                         ndr->depth--;
7185                 break;
7186
7187                 case 1:
7188                         ndr_print_ptr(ndr, "info1", r->info1);
7189                         ndr->depth++;
7190                         if (r->info1) {
7191                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7192                         }
7193                         ndr->depth--;
7194                 break;
7195
7196                 case 2:
7197                         ndr_print_ptr(ndr, "info2", r->info2);
7198                         ndr->depth++;
7199                         if (r->info2) {
7200                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7201                         }
7202                         ndr->depth--;
7203                 break;
7204
7205                 case 3:
7206                         ndr_print_ptr(ndr, "info3", r->info3);
7207                         ndr->depth++;
7208                         if (r->info3) {
7209                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7210                         }
7211                         ndr->depth--;
7212                 break;
7213
7214                 case 4:
7215                         ndr_print_ptr(ndr, "info4", r->info4);
7216                         ndr->depth++;
7217                         if (r->info4) {
7218                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7219                         }
7220                         ndr->depth--;
7221                 break;
7222
7223                 case 5:
7224                         ndr_print_ptr(ndr, "info5", r->info5);
7225                         ndr->depth++;
7226                         if (r->info5) {
7227                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7228                         }
7229                         ndr->depth--;
7230                 break;
7231
7232                 case 6:
7233                         ndr_print_ptr(ndr, "info6", r->info6);
7234                         ndr->depth++;
7235                         if (r->info6) {
7236                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7237                         }
7238                         ndr->depth--;
7239                 break;
7240
7241                 case 7:
7242                         ndr_print_ptr(ndr, "info7", r->info7);
7243                         ndr->depth++;
7244                         if (r->info7) {
7245                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7246                         }
7247                         ndr->depth--;
7248                 break;
7249
7250                 case 8:
7251                         ndr_print_ptr(ndr, "info8", r->info8);
7252                         ndr->depth++;
7253                         if (r->info8) {
7254                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7255                         }
7256                         ndr->depth--;
7257                 break;
7258
7259                 case 9:
7260                         ndr_print_ptr(ndr, "info9", r->info9);
7261                         ndr->depth++;
7262                         if (r->info9) {
7263                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7264                         }
7265                         ndr->depth--;
7266                 break;
7267
7268                 default:
7269                 break;
7270
7271         }
7272 }
7273
7274 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7275 {
7276         if (ndr_flags & NDR_SCALARS) {
7277                 NDR_CHECK(ndr_push_align(ndr, 4));
7278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7279                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7280                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7281         }
7282         if (ndr_flags & NDR_BUFFERS) {
7283                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7284         }
7285         return NDR_ERR_SUCCESS;
7286 }
7287
7288 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7289 {
7290         if (ndr_flags & NDR_SCALARS) {
7291                 NDR_CHECK(ndr_pull_align(ndr, 4));
7292                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7293                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7294                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7295         }
7296         if (ndr_flags & NDR_BUFFERS) {
7297                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7298         }
7299         return NDR_ERR_SUCCESS;
7300 }
7301
7302 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7303 {
7304         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7305         ndr->depth++;
7306         ndr_print_uint32(ndr, "level", r->level);
7307         ndr_print_set_switch_value(ndr, &r->info, r->level);
7308         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7309         ndr->depth--;
7310 }
7311
7312 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7313 {
7314         if (ndr_flags & NDR_SCALARS) {
7315                 NDR_CHECK(ndr_push_align(ndr, 4));
7316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7317                 {
7318                         uint32_t _flags_save_string_array = ndr->flags;
7319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7320                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7321                         ndr->flags = _flags_save_string_array;
7322                 }
7323         }
7324         if (ndr_flags & NDR_BUFFERS) {
7325         }
7326         return NDR_ERR_SUCCESS;
7327 }
7328
7329 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7330 {
7331         if (ndr_flags & NDR_SCALARS) {
7332                 NDR_CHECK(ndr_pull_align(ndr, 4));
7333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7334                 {
7335                         uint32_t _flags_save_string_array = ndr->flags;
7336                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7337                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7338                         ndr->flags = _flags_save_string_array;
7339                 }
7340         }
7341         if (ndr_flags & NDR_BUFFERS) {
7342         }
7343         return NDR_ERR_SUCCESS;
7344 }
7345
7346 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7347 {
7348         ndr_print_struct(ndr, name, "spoolss_StringArray");
7349         ndr->depth++;
7350         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
7351         ndr_print_string_array(ndr, "string", r->string);
7352         ndr->depth--;
7353 }
7354
7355 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7356 {
7357         if (ndr_flags & NDR_SCALARS) {
7358                 NDR_CHECK(ndr_push_align(ndr, 4));
7359                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7360         }
7361         if (ndr_flags & NDR_BUFFERS) {
7362                 if (r->driver_name) {
7363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7366                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7367                 }
7368         }
7369         return NDR_ERR_SUCCESS;
7370 }
7371
7372 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7373 {
7374         uint32_t _ptr_driver_name;
7375         TALLOC_CTX *_mem_save_driver_name_0;
7376         if (ndr_flags & NDR_SCALARS) {
7377                 NDR_CHECK(ndr_pull_align(ndr, 4));
7378                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7379                 if (_ptr_driver_name) {
7380                         NDR_PULL_ALLOC(ndr, r->driver_name);
7381                 } else {
7382                         r->driver_name = NULL;
7383                 }
7384         }
7385         if (ndr_flags & NDR_BUFFERS) {
7386                 if (r->driver_name) {
7387                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7388                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7389                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7390                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7391                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7392                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7393                         }
7394                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7395                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7396                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7397                 }
7398         }
7399         return NDR_ERR_SUCCESS;
7400 }
7401
7402 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7403 {
7404         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7405         ndr->depth++;
7406         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7407         ndr->depth++;
7408         if (r->driver_name) {
7409                 ndr_print_string(ndr, "driver_name", r->driver_name);
7410         }
7411         ndr->depth--;
7412         ndr->depth--;
7413 }
7414
7415 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7416 {
7417         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7418         return NDR_ERR_SUCCESS;
7419 }
7420
7421 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7422 {
7423         uint32_t v;
7424         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7425         *r = v;
7426         return NDR_ERR_SUCCESS;
7427 }
7428
7429 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7430 {
7431         const char *val = NULL;
7432
7433         switch (r) {
7434                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7435                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7436                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7437                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7438         }
7439         ndr_print_enum(ndr, name, "ENUM", val, r);
7440 }
7441
7442 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7443 {
7444         if (ndr_flags & NDR_SCALARS) {
7445                 NDR_CHECK(ndr_push_align(ndr, 4));
7446                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7448                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7449                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7450                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7451                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7452         }
7453         if (ndr_flags & NDR_BUFFERS) {
7454                 if (r->driver_name) {
7455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7459                 }
7460                 if (r->architecture) {
7461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7464                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7465                 }
7466                 if (r->driver_path) {
7467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7470                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7471                 }
7472                 if (r->data_file) {
7473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7476                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7477                 }
7478                 if (r->config_file) {
7479                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7480                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7481                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7482                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7483                 }
7484         }
7485         return NDR_ERR_SUCCESS;
7486 }
7487
7488 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7489 {
7490         uint32_t _ptr_driver_name;
7491         TALLOC_CTX *_mem_save_driver_name_0;
7492         uint32_t _ptr_architecture;
7493         TALLOC_CTX *_mem_save_architecture_0;
7494         uint32_t _ptr_driver_path;
7495         TALLOC_CTX *_mem_save_driver_path_0;
7496         uint32_t _ptr_data_file;
7497         TALLOC_CTX *_mem_save_data_file_0;
7498         uint32_t _ptr_config_file;
7499         TALLOC_CTX *_mem_save_config_file_0;
7500         if (ndr_flags & NDR_SCALARS) {
7501                 NDR_CHECK(ndr_pull_align(ndr, 4));
7502                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7503                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7504                 if (_ptr_driver_name) {
7505                         NDR_PULL_ALLOC(ndr, r->driver_name);
7506                 } else {
7507                         r->driver_name = NULL;
7508                 }
7509                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7510                 if (_ptr_architecture) {
7511                         NDR_PULL_ALLOC(ndr, r->architecture);
7512                 } else {
7513                         r->architecture = NULL;
7514                 }
7515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7516                 if (_ptr_driver_path) {
7517                         NDR_PULL_ALLOC(ndr, r->driver_path);
7518                 } else {
7519                         r->driver_path = NULL;
7520                 }
7521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7522                 if (_ptr_data_file) {
7523                         NDR_PULL_ALLOC(ndr, r->data_file);
7524                 } else {
7525                         r->data_file = NULL;
7526                 }
7527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7528                 if (_ptr_config_file) {
7529                         NDR_PULL_ALLOC(ndr, r->config_file);
7530                 } else {
7531                         r->config_file = NULL;
7532                 }
7533         }
7534         if (ndr_flags & NDR_BUFFERS) {
7535                 if (r->driver_name) {
7536                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7537                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7538                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7539                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7540                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7541                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7542                         }
7543                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7544                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7546                 }
7547                 if (r->architecture) {
7548                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7549                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7550                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7551                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7552                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7553                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7554                         }
7555                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7556                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7558                 }
7559                 if (r->driver_path) {
7560                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7561                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7564                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7565                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7566                         }
7567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7568                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7570                 }
7571                 if (r->data_file) {
7572                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7573                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7574                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7575                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7576                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7577                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7578                         }
7579                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7580                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7581                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7582                 }
7583                 if (r->config_file) {
7584                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7585                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7586                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7587                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7588                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7589                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7590                         }
7591                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7592                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7593                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7594                 }
7595         }
7596         return NDR_ERR_SUCCESS;
7597 }
7598
7599 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7600 {
7601         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7602         ndr->depth++;
7603         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7604         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7605         ndr->depth++;
7606         if (r->driver_name) {
7607                 ndr_print_string(ndr, "driver_name", r->driver_name);
7608         }
7609         ndr->depth--;
7610         ndr_print_ptr(ndr, "architecture", r->architecture);
7611         ndr->depth++;
7612         if (r->architecture) {
7613                 ndr_print_string(ndr, "architecture", r->architecture);
7614         }
7615         ndr->depth--;
7616         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7617         ndr->depth++;
7618         if (r->driver_path) {
7619                 ndr_print_string(ndr, "driver_path", r->driver_path);
7620         }
7621         ndr->depth--;
7622         ndr_print_ptr(ndr, "data_file", r->data_file);
7623         ndr->depth++;
7624         if (r->data_file) {
7625                 ndr_print_string(ndr, "data_file", r->data_file);
7626         }
7627         ndr->depth--;
7628         ndr_print_ptr(ndr, "config_file", r->config_file);
7629         ndr->depth++;
7630         if (r->config_file) {
7631                 ndr_print_string(ndr, "config_file", r->config_file);
7632         }
7633         ndr->depth--;
7634         ndr->depth--;
7635 }
7636
7637 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7638 {
7639         if (ndr_flags & NDR_SCALARS) {
7640                 NDR_CHECK(ndr_push_align(ndr, 4));
7641                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7642                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7644                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7645                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7646                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7647                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7648                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7649                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7652         }
7653         if (ndr_flags & NDR_BUFFERS) {
7654                 if (r->driver_name) {
7655                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7656                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7658                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7659                 }
7660                 if (r->architecture) {
7661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7663                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7664                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7665                 }
7666                 if (r->driver_path) {
7667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7670                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7671                 }
7672                 if (r->data_file) {
7673                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7674                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7675                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7676                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7677                 }
7678                 if (r->config_file) {
7679                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7682                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7683                 }
7684                 if (r->help_file) {
7685                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7686                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7688                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7689                 }
7690                 if (r->monitor_name) {
7691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7693                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7694                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7695                 }
7696                 if (r->default_datatype) {
7697                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7698                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7699                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7700                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7701                 }
7702                 if (r->dependent_files) {
7703                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7704                 }
7705         }
7706         return NDR_ERR_SUCCESS;
7707 }
7708
7709 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7710 {
7711         uint32_t _ptr_driver_name;
7712         TALLOC_CTX *_mem_save_driver_name_0;
7713         uint32_t _ptr_architecture;
7714         TALLOC_CTX *_mem_save_architecture_0;
7715         uint32_t _ptr_driver_path;
7716         TALLOC_CTX *_mem_save_driver_path_0;
7717         uint32_t _ptr_data_file;
7718         TALLOC_CTX *_mem_save_data_file_0;
7719         uint32_t _ptr_config_file;
7720         TALLOC_CTX *_mem_save_config_file_0;
7721         uint32_t _ptr_help_file;
7722         TALLOC_CTX *_mem_save_help_file_0;
7723         uint32_t _ptr_monitor_name;
7724         TALLOC_CTX *_mem_save_monitor_name_0;
7725         uint32_t _ptr_default_datatype;
7726         TALLOC_CTX *_mem_save_default_datatype_0;
7727         uint32_t _ptr_dependent_files;
7728         TALLOC_CTX *_mem_save_dependent_files_0;
7729         if (ndr_flags & NDR_SCALARS) {
7730                 NDR_CHECK(ndr_pull_align(ndr, 4));
7731                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7732                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7733                 if (_ptr_driver_name) {
7734                         NDR_PULL_ALLOC(ndr, r->driver_name);
7735                 } else {
7736                         r->driver_name = NULL;
7737                 }
7738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7739                 if (_ptr_architecture) {
7740                         NDR_PULL_ALLOC(ndr, r->architecture);
7741                 } else {
7742                         r->architecture = NULL;
7743                 }
7744                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7745                 if (_ptr_driver_path) {
7746                         NDR_PULL_ALLOC(ndr, r->driver_path);
7747                 } else {
7748                         r->driver_path = NULL;
7749                 }
7750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7751                 if (_ptr_data_file) {
7752                         NDR_PULL_ALLOC(ndr, r->data_file);
7753                 } else {
7754                         r->data_file = NULL;
7755                 }
7756                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7757                 if (_ptr_config_file) {
7758                         NDR_PULL_ALLOC(ndr, r->config_file);
7759                 } else {
7760                         r->config_file = NULL;
7761                 }
7762                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7763                 if (_ptr_help_file) {
7764                         NDR_PULL_ALLOC(ndr, r->help_file);
7765                 } else {
7766                         r->help_file = NULL;
7767                 }
7768                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7769                 if (_ptr_monitor_name) {
7770                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7771                 } else {
7772                         r->monitor_name = NULL;
7773                 }
7774                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7775                 if (_ptr_default_datatype) {
7776                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7777                 } else {
7778                         r->default_datatype = NULL;
7779                 }
7780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7781                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7782                 if (_ptr_dependent_files) {
7783                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7784                 } else {
7785                         r->dependent_files = NULL;
7786                 }
7787         }
7788         if (ndr_flags & NDR_BUFFERS) {
7789                 if (r->driver_name) {
7790                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7791                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7792                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7793                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7794                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7795                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7796                         }
7797                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7798                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7799                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7800                 }
7801                 if (r->architecture) {
7802                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7803                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7804                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7805                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7806                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7807                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7808                         }
7809                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7810                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7811                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7812                 }
7813                 if (r->driver_path) {
7814                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7815                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7816                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7817                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7818                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7819                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7820                         }
7821                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7822                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7824                 }
7825                 if (r->data_file) {
7826                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7827                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7828                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7829                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7830                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7831                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7832                         }
7833                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7834                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7836                 }
7837                 if (r->config_file) {
7838                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7839                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7840                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7841                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7842                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7843                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7844                         }
7845                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7846                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7848                 }
7849                 if (r->help_file) {
7850                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7851                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7852                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7853                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7854                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7855                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
7856                         }
7857                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7858                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7859                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7860                 }
7861                 if (r->monitor_name) {
7862                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7863                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7864                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7865                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7866                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7867                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
7868                         }
7869                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7870                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7871                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7872                 }
7873                 if (r->default_datatype) {
7874                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7875                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7876                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7877                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7878                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7879                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
7880                         }
7881                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7882                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7883                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7884                 }
7885                 if (r->dependent_files) {
7886                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7887                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7888                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7890                 }
7891         }
7892         return NDR_ERR_SUCCESS;
7893 }
7894
7895 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7896 {
7897         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7898         ndr->depth++;
7899         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7900         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7901         ndr->depth++;
7902         if (r->driver_name) {
7903                 ndr_print_string(ndr, "driver_name", r->driver_name);
7904         }
7905         ndr->depth--;
7906         ndr_print_ptr(ndr, "architecture", r->architecture);
7907         ndr->depth++;
7908         if (r->architecture) {
7909                 ndr_print_string(ndr, "architecture", r->architecture);
7910         }
7911         ndr->depth--;
7912         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7913         ndr->depth++;
7914         if (r->driver_path) {
7915                 ndr_print_string(ndr, "driver_path", r->driver_path);
7916         }
7917         ndr->depth--;
7918         ndr_print_ptr(ndr, "data_file", r->data_file);
7919         ndr->depth++;
7920         if (r->data_file) {
7921                 ndr_print_string(ndr, "data_file", r->data_file);
7922         }
7923         ndr->depth--;
7924         ndr_print_ptr(ndr, "config_file", r->config_file);
7925         ndr->depth++;
7926         if (r->config_file) {
7927                 ndr_print_string(ndr, "config_file", r->config_file);
7928         }
7929         ndr->depth--;
7930         ndr_print_ptr(ndr, "help_file", r->help_file);
7931         ndr->depth++;
7932         if (r->help_file) {
7933                 ndr_print_string(ndr, "help_file", r->help_file);
7934         }
7935         ndr->depth--;
7936         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
7937         ndr->depth++;
7938         if (r->monitor_name) {
7939                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
7940         }
7941         ndr->depth--;
7942         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
7943         ndr->depth++;
7944         if (r->default_datatype) {
7945                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
7946         }
7947         ndr->depth--;
7948         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
7949         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
7950         ndr->depth++;
7951         if (r->dependent_files) {
7952                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
7953         }
7954         ndr->depth--;
7955         ndr->depth--;
7956 }
7957
7958 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
7959 {
7960         if (ndr_flags & NDR_SCALARS) {
7961                 NDR_CHECK(ndr_push_align(ndr, 4));
7962                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7966                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7967                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7968                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7969                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7970                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7972                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7974                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
7975         }
7976         if (ndr_flags & NDR_BUFFERS) {
7977                 if (r->driver_name) {
7978                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7981                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7982                 }
7983                 if (r->architecture) {
7984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7987                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7988                 }
7989                 if (r->driver_path) {
7990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7993                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7994                 }
7995                 if (r->data_file) {
7996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7999                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8000                 }
8001                 if (r->config_file) {
8002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8005                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8006                 }
8007                 if (r->help_file) {
8008                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8011                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8012                 }
8013                 if (r->monitor_name) {
8014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8015                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8017                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8018                 }
8019                 if (r->default_datatype) {
8020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8021                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8022                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8023                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8024                 }
8025                 if (r->dependent_files) {
8026                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8027                 }
8028                 if (r->previous_names) {
8029                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8030                 }
8031         }
8032         return NDR_ERR_SUCCESS;
8033 }
8034
8035 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8036 {
8037         uint32_t _ptr_driver_name;
8038         TALLOC_CTX *_mem_save_driver_name_0;
8039         uint32_t _ptr_architecture;
8040         TALLOC_CTX *_mem_save_architecture_0;
8041         uint32_t _ptr_driver_path;
8042         TALLOC_CTX *_mem_save_driver_path_0;
8043         uint32_t _ptr_data_file;
8044         TALLOC_CTX *_mem_save_data_file_0;
8045         uint32_t _ptr_config_file;
8046         TALLOC_CTX *_mem_save_config_file_0;
8047         uint32_t _ptr_help_file;
8048         TALLOC_CTX *_mem_save_help_file_0;
8049         uint32_t _ptr_monitor_name;
8050         TALLOC_CTX *_mem_save_monitor_name_0;
8051         uint32_t _ptr_default_datatype;
8052         TALLOC_CTX *_mem_save_default_datatype_0;
8053         uint32_t _ptr_dependent_files;
8054         TALLOC_CTX *_mem_save_dependent_files_0;
8055         uint32_t _ptr_previous_names;
8056         TALLOC_CTX *_mem_save_previous_names_0;
8057         if (ndr_flags & NDR_SCALARS) {
8058                 NDR_CHECK(ndr_pull_align(ndr, 4));
8059                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8060                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8061                 if (_ptr_driver_name) {
8062                         NDR_PULL_ALLOC(ndr, r->driver_name);
8063                 } else {
8064                         r->driver_name = NULL;
8065                 }
8066                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8067                 if (_ptr_architecture) {
8068                         NDR_PULL_ALLOC(ndr, r->architecture);
8069                 } else {
8070                         r->architecture = NULL;
8071                 }
8072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8073                 if (_ptr_driver_path) {
8074                         NDR_PULL_ALLOC(ndr, r->driver_path);
8075                 } else {
8076                         r->driver_path = NULL;
8077                 }
8078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8079                 if (_ptr_data_file) {
8080                         NDR_PULL_ALLOC(ndr, r->data_file);
8081                 } else {
8082                         r->data_file = NULL;
8083                 }
8084                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8085                 if (_ptr_config_file) {
8086                         NDR_PULL_ALLOC(ndr, r->config_file);
8087                 } else {
8088                         r->config_file = NULL;
8089                 }
8090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8091                 if (_ptr_help_file) {
8092                         NDR_PULL_ALLOC(ndr, r->help_file);
8093                 } else {
8094                         r->help_file = NULL;
8095                 }
8096                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8097                 if (_ptr_monitor_name) {
8098                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8099                 } else {
8100                         r->monitor_name = NULL;
8101                 }
8102                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8103                 if (_ptr_default_datatype) {
8104                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8105                 } else {
8106                         r->default_datatype = NULL;
8107                 }
8108                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8110                 if (_ptr_dependent_files) {
8111                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8112                 } else {
8113                         r->dependent_files = NULL;
8114                 }
8115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8117                 if (_ptr_previous_names) {
8118                         NDR_PULL_ALLOC(ndr, r->previous_names);
8119                 } else {
8120                         r->previous_names = NULL;
8121                 }
8122         }
8123         if (ndr_flags & NDR_BUFFERS) {
8124                 if (r->driver_name) {
8125                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8126                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8127                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8128                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8129                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8130                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8131                         }
8132                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8133                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8135                 }
8136                 if (r->architecture) {
8137                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8138                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8139                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8140                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8141                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8142                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8143                         }
8144                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8145                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8147                 }
8148                 if (r->driver_path) {
8149                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8150                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8151                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8152                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8153                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8154                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8155                         }
8156                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8157                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8159                 }
8160                 if (r->data_file) {
8161                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8162                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8163                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8164                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8165                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8166                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8167                         }
8168                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8169                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8170                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8171                 }
8172                 if (r->config_file) {
8173                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8174                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8175                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8176                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8177                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8178                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8179                         }
8180                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8181                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8183                 }
8184                 if (r->help_file) {
8185                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8186                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8187                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8188                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8189                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8190                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8191                         }
8192                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8193                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8195                 }
8196                 if (r->monitor_name) {
8197                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8198                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8199                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8200                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8201                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8202                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8203                         }
8204                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8205                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8206                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8207                 }
8208                 if (r->default_datatype) {
8209                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8210                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8211                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8212                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8213                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8214                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8215                         }
8216                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8217                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8219                 }
8220                 if (r->dependent_files) {
8221                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8222                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8223                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8225                 }
8226                 if (r->previous_names) {
8227                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8228                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8229                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8231                 }
8232         }
8233         return NDR_ERR_SUCCESS;
8234 }
8235
8236 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8237 {
8238         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8239         ndr->depth++;
8240         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8241         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8242         ndr->depth++;
8243         if (r->driver_name) {
8244                 ndr_print_string(ndr, "driver_name", r->driver_name);
8245         }
8246         ndr->depth--;
8247         ndr_print_ptr(ndr, "architecture", r->architecture);
8248         ndr->depth++;
8249         if (r->architecture) {
8250                 ndr_print_string(ndr, "architecture", r->architecture);
8251         }
8252         ndr->depth--;
8253         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8254         ndr->depth++;
8255         if (r->driver_path) {
8256                 ndr_print_string(ndr, "driver_path", r->driver_path);
8257         }
8258         ndr->depth--;
8259         ndr_print_ptr(ndr, "data_file", r->data_file);
8260         ndr->depth++;
8261         if (r->data_file) {
8262                 ndr_print_string(ndr, "data_file", r->data_file);
8263         }
8264         ndr->depth--;
8265         ndr_print_ptr(ndr, "config_file", r->config_file);
8266         ndr->depth++;
8267         if (r->config_file) {
8268                 ndr_print_string(ndr, "config_file", r->config_file);
8269         }
8270         ndr->depth--;
8271         ndr_print_ptr(ndr, "help_file", r->help_file);
8272         ndr->depth++;
8273         if (r->help_file) {
8274                 ndr_print_string(ndr, "help_file", r->help_file);
8275         }
8276         ndr->depth--;
8277         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8278         ndr->depth++;
8279         if (r->monitor_name) {
8280                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8281         }
8282         ndr->depth--;
8283         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8284         ndr->depth++;
8285         if (r->default_datatype) {
8286                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8287         }
8288         ndr->depth--;
8289         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8290         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8291         ndr->depth++;
8292         if (r->dependent_files) {
8293                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8294         }
8295         ndr->depth--;
8296         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
8297         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8298         ndr->depth++;
8299         if (r->previous_names) {
8300                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8301         }
8302         ndr->depth--;
8303         ndr->depth--;
8304 }
8305
8306 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8307 {
8308         if (ndr_flags & NDR_SCALARS) {
8309                 NDR_CHECK(ndr_push_align(ndr, 8));
8310                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8311                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8312                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8314                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8315                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8316                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8317                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8318                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8320                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8323                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8324                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8325                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8326                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8329         }
8330         if (ndr_flags & NDR_BUFFERS) {
8331                 if (r->driver_name) {
8332                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8335                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8336                 }
8337                 if (r->architecture) {
8338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8342                 }
8343                 if (r->driver_path) {
8344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8347                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8348                 }
8349                 if (r->data_file) {
8350                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8351                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8352                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8353                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8354                 }
8355                 if (r->config_file) {
8356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8358                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8359                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8360                 }
8361                 if (r->help_file) {
8362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8365                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8366                 }
8367                 if (r->monitor_name) {
8368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8371                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8372                 }
8373                 if (r->default_datatype) {
8374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8378                 }
8379                 if (r->dependent_files) {
8380                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8381                 }
8382                 if (r->previous_names) {
8383                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8384                 }
8385                 if (r->manufacturer_name) {
8386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8390                 }
8391                 if (r->manufacturer_url) {
8392                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8393                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8394                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8395                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8396                 }
8397                 if (r->hardware_id) {
8398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8399                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8401                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8402                 }
8403                 if (r->provider) {
8404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8407                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8408                 }
8409         }
8410         return NDR_ERR_SUCCESS;
8411 }
8412
8413 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8414 {
8415         uint32_t _ptr_driver_name;
8416         TALLOC_CTX *_mem_save_driver_name_0;
8417         uint32_t _ptr_architecture;
8418         TALLOC_CTX *_mem_save_architecture_0;
8419         uint32_t _ptr_driver_path;
8420         TALLOC_CTX *_mem_save_driver_path_0;
8421         uint32_t _ptr_data_file;
8422         TALLOC_CTX *_mem_save_data_file_0;
8423         uint32_t _ptr_config_file;
8424         TALLOC_CTX *_mem_save_config_file_0;
8425         uint32_t _ptr_help_file;
8426         TALLOC_CTX *_mem_save_help_file_0;
8427         uint32_t _ptr_monitor_name;
8428         TALLOC_CTX *_mem_save_monitor_name_0;
8429         uint32_t _ptr_default_datatype;
8430         TALLOC_CTX *_mem_save_default_datatype_0;
8431         uint32_t _ptr_dependent_files;
8432         TALLOC_CTX *_mem_save_dependent_files_0;
8433         uint32_t _ptr_previous_names;
8434         TALLOC_CTX *_mem_save_previous_names_0;
8435         uint32_t _ptr_manufacturer_name;
8436         TALLOC_CTX *_mem_save_manufacturer_name_0;
8437         uint32_t _ptr_manufacturer_url;
8438         TALLOC_CTX *_mem_save_manufacturer_url_0;
8439         uint32_t _ptr_hardware_id;
8440         TALLOC_CTX *_mem_save_hardware_id_0;
8441         uint32_t _ptr_provider;
8442         TALLOC_CTX *_mem_save_provider_0;
8443         if (ndr_flags & NDR_SCALARS) {
8444                 NDR_CHECK(ndr_pull_align(ndr, 8));
8445                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8446                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8447                 if (_ptr_driver_name) {
8448                         NDR_PULL_ALLOC(ndr, r->driver_name);
8449                 } else {
8450                         r->driver_name = NULL;
8451                 }
8452                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8453                 if (_ptr_architecture) {
8454                         NDR_PULL_ALLOC(ndr, r->architecture);
8455                 } else {
8456                         r->architecture = NULL;
8457                 }
8458                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8459                 if (_ptr_driver_path) {
8460                         NDR_PULL_ALLOC(ndr, r->driver_path);
8461                 } else {
8462                         r->driver_path = NULL;
8463                 }
8464                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8465                 if (_ptr_data_file) {
8466                         NDR_PULL_ALLOC(ndr, r->data_file);
8467                 } else {
8468                         r->data_file = NULL;
8469                 }
8470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8471                 if (_ptr_config_file) {
8472                         NDR_PULL_ALLOC(ndr, r->config_file);
8473                 } else {
8474                         r->config_file = NULL;
8475                 }
8476                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8477                 if (_ptr_help_file) {
8478                         NDR_PULL_ALLOC(ndr, r->help_file);
8479                 } else {
8480                         r->help_file = NULL;
8481                 }
8482                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8483                 if (_ptr_monitor_name) {
8484                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8485                 } else {
8486                         r->monitor_name = NULL;
8487                 }
8488                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8489                 if (_ptr_default_datatype) {
8490                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8491                 } else {
8492                         r->default_datatype = NULL;
8493                 }
8494                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8495                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8496                 if (_ptr_dependent_files) {
8497                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8498                 } else {
8499                         r->dependent_files = NULL;
8500                 }
8501                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8503                 if (_ptr_previous_names) {
8504                         NDR_PULL_ALLOC(ndr, r->previous_names);
8505                 } else {
8506                         r->previous_names = NULL;
8507                 }
8508                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8509                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8511                 if (_ptr_manufacturer_name) {
8512                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8513                 } else {
8514                         r->manufacturer_name = NULL;
8515                 }
8516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8517                 if (_ptr_manufacturer_url) {
8518                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8519                 } else {
8520                         r->manufacturer_url = NULL;
8521                 }
8522                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8523                 if (_ptr_hardware_id) {
8524                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8525                 } else {
8526                         r->hardware_id = NULL;
8527                 }
8528                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8529                 if (_ptr_provider) {
8530                         NDR_PULL_ALLOC(ndr, r->provider);
8531                 } else {
8532                         r->provider = NULL;
8533                 }
8534         }
8535         if (ndr_flags & NDR_BUFFERS) {
8536                 if (r->driver_name) {
8537                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8538                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8539                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8540                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8541                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8542                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8543                         }
8544                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8545                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8546                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8547                 }
8548                 if (r->architecture) {
8549                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8550                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8551                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8552                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8553                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8554                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8555                         }
8556                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8557                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8558                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8559                 }
8560                 if (r->driver_path) {
8561                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8562                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8563                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8564                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8565                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8566                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8567                         }
8568                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8569                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8571                 }
8572                 if (r->data_file) {
8573                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8574                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8575                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8576                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8577                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8578                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8579                         }
8580                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8581                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8583                 }
8584                 if (r->config_file) {
8585                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8586                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8587                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8588                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8589                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8590                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8591                         }
8592                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8593                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8595                 }
8596                 if (r->help_file) {
8597                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8598                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8599                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8600                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8601                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8602                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8603                         }
8604                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8605                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8606                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8607                 }
8608                 if (r->monitor_name) {
8609                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8610                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8611                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8612                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8613                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8614                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8615                         }
8616                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8617                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8618                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8619                 }
8620                 if (r->default_datatype) {
8621                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8622                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8623                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8624                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8625                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8626                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8627                         }
8628                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8629                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8631                 }
8632                 if (r->dependent_files) {
8633                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8634                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8635                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8636                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8637                 }
8638                 if (r->previous_names) {
8639                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8640                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8641                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8642                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8643                 }
8644                 if (r->manufacturer_name) {
8645                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8646                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8647                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8648                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8649                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8650                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
8651                         }
8652                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8653                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8654                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8655                 }
8656                 if (r->manufacturer_url) {
8657                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8658                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8659                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8660                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8661                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8662                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
8663                         }
8664                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8665                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8666                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8667                 }
8668                 if (r->hardware_id) {
8669                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8670                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8673                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8674                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
8675                         }
8676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8677                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8679                 }
8680                 if (r->provider) {
8681                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8682                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8683                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8684                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8685                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8686                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
8687                         }
8688                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8689                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8690                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8691                 }
8692         }
8693         return NDR_ERR_SUCCESS;
8694 }
8695
8696 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8697 {
8698         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8699         ndr->depth++;
8700         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8701         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8702         ndr->depth++;
8703         if (r->driver_name) {
8704                 ndr_print_string(ndr, "driver_name", r->driver_name);
8705         }
8706         ndr->depth--;
8707         ndr_print_ptr(ndr, "architecture", r->architecture);
8708         ndr->depth++;
8709         if (r->architecture) {
8710                 ndr_print_string(ndr, "architecture", r->architecture);
8711         }
8712         ndr->depth--;
8713         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8714         ndr->depth++;
8715         if (r->driver_path) {
8716                 ndr_print_string(ndr, "driver_path", r->driver_path);
8717         }
8718         ndr->depth--;
8719         ndr_print_ptr(ndr, "data_file", r->data_file);
8720         ndr->depth++;
8721         if (r->data_file) {
8722                 ndr_print_string(ndr, "data_file", r->data_file);
8723         }
8724         ndr->depth--;
8725         ndr_print_ptr(ndr, "config_file", r->config_file);
8726         ndr->depth++;
8727         if (r->config_file) {
8728                 ndr_print_string(ndr, "config_file", r->config_file);
8729         }
8730         ndr->depth--;
8731         ndr_print_ptr(ndr, "help_file", r->help_file);
8732         ndr->depth++;
8733         if (r->help_file) {
8734                 ndr_print_string(ndr, "help_file", r->help_file);
8735         }
8736         ndr->depth--;
8737         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8738         ndr->depth++;
8739         if (r->monitor_name) {
8740                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8741         }
8742         ndr->depth--;
8743         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8744         ndr->depth++;
8745         if (r->default_datatype) {
8746                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8747         }
8748         ndr->depth--;
8749         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8750         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8751         ndr->depth++;
8752         if (r->dependent_files) {
8753                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8754         }
8755         ndr->depth--;
8756         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
8757         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8758         ndr->depth++;
8759         if (r->previous_names) {
8760                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8761         }
8762         ndr->depth--;
8763         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8764         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8765         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8766         ndr->depth++;
8767         if (r->manufacturer_name) {
8768                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8769         }
8770         ndr->depth--;
8771         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8772         ndr->depth++;
8773         if (r->manufacturer_url) {
8774                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8775         }
8776         ndr->depth--;
8777         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8778         ndr->depth++;
8779         if (r->hardware_id) {
8780                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8781         }
8782         ndr->depth--;
8783         ndr_print_ptr(ndr, "provider", r->provider);
8784         ndr->depth++;
8785         if (r->provider) {
8786                 ndr_print_string(ndr, "provider", r->provider);
8787         }
8788         ndr->depth--;
8789         ndr->depth--;
8790 }
8791
8792 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8793 {
8794         if (ndr_flags & NDR_SCALARS) {
8795                 NDR_CHECK(ndr_push_align(ndr, 8));
8796                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8797                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8798                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8799                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8800                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8801                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8802                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8806                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8808                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8809                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8810                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8811                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8812                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8813                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8815                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8817                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8818                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8819                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8820                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8821                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8822                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8823                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8824                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8825         }
8826         if (ndr_flags & NDR_BUFFERS) {
8827                 if (r->driver_name) {
8828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8830                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8831                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8832                 }
8833                 if (r->architecture) {
8834                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8835                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8837                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8838                 }
8839                 if (r->driver_path) {
8840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8842                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8843                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8844                 }
8845                 if (r->data_file) {
8846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8848                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8849                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8850                 }
8851                 if (r->config_file) {
8852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8854                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8856                 }
8857                 if (r->help_file) {
8858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8860                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8861                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8862                 }
8863                 if (r->monitor_name) {
8864                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8865                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8866                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8867                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8868                 }
8869                 if (r->default_datatype) {
8870                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8871                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8872                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8873                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8874                 }
8875                 if (r->dependent_files) {
8876                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8877                 }
8878                 if (r->previous_names) {
8879                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8880                 }
8881                 if (r->manufacturer_name) {
8882                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8883                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8884                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8885                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8886                 }
8887                 if (r->manufacturer_url) {
8888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8891                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8892                 }
8893                 if (r->hardware_id) {
8894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8895                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8896                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8897                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8898                 }
8899                 if (r->provider) {
8900                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8903                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8904                 }
8905                 if (r->print_processor) {
8906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8909                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8910                 }
8911                 if (r->vendor_setup) {
8912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8913                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8914                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8915                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8916                 }
8917                 if (r->color_profiles) {
8918                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8919                 }
8920                 if (r->inf_path) {
8921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8924                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8925                 }
8926                 if (r->core_driver_dependencies) {
8927                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8928                 }
8929         }
8930         return NDR_ERR_SUCCESS;
8931 }
8932
8933 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
8934 {
8935         uint32_t _ptr_driver_name;
8936         TALLOC_CTX *_mem_save_driver_name_0;
8937         uint32_t _ptr_architecture;
8938         TALLOC_CTX *_mem_save_architecture_0;
8939         uint32_t _ptr_driver_path;
8940         TALLOC_CTX *_mem_save_driver_path_0;
8941         uint32_t _ptr_data_file;
8942         TALLOC_CTX *_mem_save_data_file_0;
8943         uint32_t _ptr_config_file;
8944         TALLOC_CTX *_mem_save_config_file_0;
8945         uint32_t _ptr_help_file;
8946         TALLOC_CTX *_mem_save_help_file_0;
8947         uint32_t _ptr_monitor_name;
8948         TALLOC_CTX *_mem_save_monitor_name_0;
8949         uint32_t _ptr_default_datatype;
8950         TALLOC_CTX *_mem_save_default_datatype_0;
8951         uint32_t _ptr_dependent_files;
8952         TALLOC_CTX *_mem_save_dependent_files_0;
8953         uint32_t _ptr_previous_names;
8954         TALLOC_CTX *_mem_save_previous_names_0;
8955         uint32_t _ptr_manufacturer_name;
8956         TALLOC_CTX *_mem_save_manufacturer_name_0;
8957         uint32_t _ptr_manufacturer_url;
8958         TALLOC_CTX *_mem_save_manufacturer_url_0;
8959         uint32_t _ptr_hardware_id;
8960         TALLOC_CTX *_mem_save_hardware_id_0;
8961         uint32_t _ptr_provider;
8962         TALLOC_CTX *_mem_save_provider_0;
8963         uint32_t _ptr_print_processor;
8964         TALLOC_CTX *_mem_save_print_processor_0;
8965         uint32_t _ptr_vendor_setup;
8966         TALLOC_CTX *_mem_save_vendor_setup_0;
8967         uint32_t _ptr_color_profiles;
8968         TALLOC_CTX *_mem_save_color_profiles_0;
8969         uint32_t _ptr_inf_path;
8970         TALLOC_CTX *_mem_save_inf_path_0;
8971         uint32_t _ptr_core_driver_dependencies;
8972         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
8973         if (ndr_flags & NDR_SCALARS) {
8974                 NDR_CHECK(ndr_pull_align(ndr, 8));
8975                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8976                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8977                 if (_ptr_driver_name) {
8978                         NDR_PULL_ALLOC(ndr, r->driver_name);
8979                 } else {
8980                         r->driver_name = NULL;
8981                 }
8982                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8983                 if (_ptr_architecture) {
8984                         NDR_PULL_ALLOC(ndr, r->architecture);
8985                 } else {
8986                         r->architecture = NULL;
8987                 }
8988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8989                 if (_ptr_driver_path) {
8990                         NDR_PULL_ALLOC(ndr, r->driver_path);
8991                 } else {
8992                         r->driver_path = NULL;
8993                 }
8994                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8995                 if (_ptr_data_file) {
8996                         NDR_PULL_ALLOC(ndr, r->data_file);
8997                 } else {
8998                         r->data_file = NULL;
8999                 }
9000                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9001                 if (_ptr_config_file) {
9002                         NDR_PULL_ALLOC(ndr, r->config_file);
9003                 } else {
9004                         r->config_file = NULL;
9005                 }
9006                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9007                 if (_ptr_help_file) {
9008                         NDR_PULL_ALLOC(ndr, r->help_file);
9009                 } else {
9010                         r->help_file = NULL;
9011                 }
9012                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9013                 if (_ptr_monitor_name) {
9014                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9015                 } else {
9016                         r->monitor_name = NULL;
9017                 }
9018                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9019                 if (_ptr_default_datatype) {
9020                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9021                 } else {
9022                         r->default_datatype = NULL;
9023                 }
9024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9025                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9026                 if (_ptr_dependent_files) {
9027                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9028                 } else {
9029                         r->dependent_files = NULL;
9030                 }
9031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9032                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9033                 if (_ptr_previous_names) {
9034                         NDR_PULL_ALLOC(ndr, r->previous_names);
9035                 } else {
9036                         r->previous_names = NULL;
9037                 }
9038                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9039                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9040                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9041                 if (_ptr_manufacturer_name) {
9042                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9043                 } else {
9044                         r->manufacturer_name = NULL;
9045                 }
9046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9047                 if (_ptr_manufacturer_url) {
9048                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9049                 } else {
9050                         r->manufacturer_url = NULL;
9051                 }
9052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9053                 if (_ptr_hardware_id) {
9054                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9055                 } else {
9056                         r->hardware_id = NULL;
9057                 }
9058                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9059                 if (_ptr_provider) {
9060                         NDR_PULL_ALLOC(ndr, r->provider);
9061                 } else {
9062                         r->provider = NULL;
9063                 }
9064                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9065                 if (_ptr_print_processor) {
9066                         NDR_PULL_ALLOC(ndr, r->print_processor);
9067                 } else {
9068                         r->print_processor = NULL;
9069                 }
9070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9071                 if (_ptr_vendor_setup) {
9072                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9073                 } else {
9074                         r->vendor_setup = NULL;
9075                 }
9076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9078                 if (_ptr_color_profiles) {
9079                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9080                 } else {
9081                         r->color_profiles = NULL;
9082                 }
9083                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9084                 if (_ptr_inf_path) {
9085                         NDR_PULL_ALLOC(ndr, r->inf_path);
9086                 } else {
9087                         r->inf_path = NULL;
9088                 }
9089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9092                 if (_ptr_core_driver_dependencies) {
9093                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9094                 } else {
9095                         r->core_driver_dependencies = NULL;
9096                 }
9097                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9098                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9099         }
9100         if (ndr_flags & NDR_BUFFERS) {
9101                 if (r->driver_name) {
9102                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9103                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9106                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9107                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9108                         }
9109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9112                 }
9113                 if (r->architecture) {
9114                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9115                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9116                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9117                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9118                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9119                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9120                         }
9121                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9122                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9124                 }
9125                 if (r->driver_path) {
9126                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9127                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9128                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9129                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9130                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9131                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9132                         }
9133                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9134                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9135                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9136                 }
9137                 if (r->data_file) {
9138                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9139                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9140                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9141                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9142                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9143                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9144                         }
9145                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9146                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9147                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9148                 }
9149                 if (r->config_file) {
9150                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9151                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9152                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9153                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9154                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9155                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9156                         }
9157                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9158                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9159                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9160                 }
9161                 if (r->help_file) {
9162                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9163                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9164                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9165                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9166                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9167                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9168                         }
9169                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9170                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9171                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9172                 }
9173                 if (r->monitor_name) {
9174                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9175                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9178                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9179                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9180                         }
9181                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9182                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9184                 }
9185                 if (r->default_datatype) {
9186                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9187                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9188                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9189                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9190                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9191                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9192                         }
9193                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9194                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9195                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9196                 }
9197                 if (r->dependent_files) {
9198                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9199                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9200                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9201                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9202                 }
9203                 if (r->previous_names) {
9204                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9205                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9206                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9208                 }
9209                 if (r->manufacturer_name) {
9210                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9211                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9212                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9213                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9214                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9215                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9216                         }
9217                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9218                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9220                 }
9221                 if (r->manufacturer_url) {
9222                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9223                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9224                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9225                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9226                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9227                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9228                         }
9229                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9230                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9231                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9232                 }
9233                 if (r->hardware_id) {
9234                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9235                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9236                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9237                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9238                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9239                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9240                         }
9241                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9242                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9244                 }
9245                 if (r->provider) {
9246                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9247                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9248                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9249                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9250                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9251                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9252                         }
9253                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9254                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9255                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9256                 }
9257                 if (r->print_processor) {
9258                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9259                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9260                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9261                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9262                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9263                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
9264                         }
9265                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9266                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9267                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9268                 }
9269                 if (r->vendor_setup) {
9270                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9271                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9272                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9273                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9274                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9275                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
9276                         }
9277                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9278                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9280                 }
9281                 if (r->color_profiles) {
9282                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9283                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9284                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9285                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9286                 }
9287                 if (r->inf_path) {
9288                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9289                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9291                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9292                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9293                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
9294                         }
9295                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9296                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9298                 }
9299                 if (r->core_driver_dependencies) {
9300                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9301                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9302                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9303                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9304                 }
9305         }
9306         return NDR_ERR_SUCCESS;
9307 }
9308
9309 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9310 {
9311         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9312         ndr->depth++;
9313         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9314         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9315         ndr->depth++;
9316         if (r->driver_name) {
9317                 ndr_print_string(ndr, "driver_name", r->driver_name);
9318         }
9319         ndr->depth--;
9320         ndr_print_ptr(ndr, "architecture", r->architecture);
9321         ndr->depth++;
9322         if (r->architecture) {
9323                 ndr_print_string(ndr, "architecture", r->architecture);
9324         }
9325         ndr->depth--;
9326         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9327         ndr->depth++;
9328         if (r->driver_path) {
9329                 ndr_print_string(ndr, "driver_path", r->driver_path);
9330         }
9331         ndr->depth--;
9332         ndr_print_ptr(ndr, "data_file", r->data_file);
9333         ndr->depth++;
9334         if (r->data_file) {
9335                 ndr_print_string(ndr, "data_file", r->data_file);
9336         }
9337         ndr->depth--;
9338         ndr_print_ptr(ndr, "config_file", r->config_file);
9339         ndr->depth++;
9340         if (r->config_file) {
9341                 ndr_print_string(ndr, "config_file", r->config_file);
9342         }
9343         ndr->depth--;
9344         ndr_print_ptr(ndr, "help_file", r->help_file);
9345         ndr->depth++;
9346         if (r->help_file) {
9347                 ndr_print_string(ndr, "help_file", r->help_file);
9348         }
9349         ndr->depth--;
9350         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9351         ndr->depth++;
9352         if (r->monitor_name) {
9353                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9354         }
9355         ndr->depth--;
9356         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9357         ndr->depth++;
9358         if (r->default_datatype) {
9359                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9360         }
9361         ndr->depth--;
9362         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9363         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9364         ndr->depth++;
9365         if (r->dependent_files) {
9366                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9367         }
9368         ndr->depth--;
9369         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9370         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9371         ndr->depth++;
9372         if (r->previous_names) {
9373                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9374         }
9375         ndr->depth--;
9376         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9377         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9378         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9379         ndr->depth++;
9380         if (r->manufacturer_name) {
9381                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9382         }
9383         ndr->depth--;
9384         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9385         ndr->depth++;
9386         if (r->manufacturer_url) {
9387                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9388         }
9389         ndr->depth--;
9390         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9391         ndr->depth++;
9392         if (r->hardware_id) {
9393                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9394         }
9395         ndr->depth--;
9396         ndr_print_ptr(ndr, "provider", r->provider);
9397         ndr->depth++;
9398         if (r->provider) {
9399                 ndr_print_string(ndr, "provider", r->provider);
9400         }
9401         ndr->depth--;
9402         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9403         ndr->depth++;
9404         if (r->print_processor) {
9405                 ndr_print_string(ndr, "print_processor", r->print_processor);
9406         }
9407         ndr->depth--;
9408         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9409         ndr->depth++;
9410         if (r->vendor_setup) {
9411                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9412         }
9413         ndr->depth--;
9414         ndr_print_uint32(ndr, "_ndr_size_color_profiles", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_color_profiles);
9415         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9416         ndr->depth++;
9417         if (r->color_profiles) {
9418                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9419         }
9420         ndr->depth--;
9421         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9422         ndr->depth++;
9423         if (r->inf_path) {
9424                 ndr_print_string(ndr, "inf_path", r->inf_path);
9425         }
9426         ndr->depth--;
9427         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9428         ndr_print_uint32(ndr, "_ndr_size_core_driver_dependencies", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_core_driver_dependencies);
9429         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9430         ndr->depth++;
9431         if (r->core_driver_dependencies) {
9432                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9433         }
9434         ndr->depth--;
9435         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9436         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9437         ndr->depth--;
9438 }
9439
9440 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9441 {
9442         if (ndr_flags & NDR_SCALARS) {
9443                 int level = ndr_push_get_switch_value(ndr, r);
9444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9445                 switch (level) {
9446                         case 1: {
9447                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9448                         break; }
9449
9450                         case 2: {
9451                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9452                         break; }
9453
9454                         case 3: {
9455                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9456                         break; }
9457
9458                         case 4: {
9459                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9460                         break; }
9461
9462                         case 6: {
9463                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9464                         break; }
9465
9466                         case 8: {
9467                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9468                         break; }
9469
9470                         default:
9471                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9472                 }
9473         }
9474         if (ndr_flags & NDR_BUFFERS) {
9475                 int level = ndr_push_get_switch_value(ndr, r);
9476                 switch (level) {
9477                         case 1:
9478                                 if (r->info1) {
9479                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9480                                 }
9481                         break;
9482
9483                         case 2:
9484                                 if (r->info2) {
9485                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9486                                 }
9487                         break;
9488
9489                         case 3:
9490                                 if (r->info3) {
9491                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9492                                 }
9493                         break;
9494
9495                         case 4:
9496                                 if (r->info4) {
9497                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9498                                 }
9499                         break;
9500
9501                         case 6:
9502                                 if (r->info6) {
9503                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9504                                 }
9505                         break;
9506
9507                         case 8:
9508                                 if (r->info8) {
9509                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9510                                 }
9511                         break;
9512
9513                         default:
9514                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9515                 }
9516         }
9517         return NDR_ERR_SUCCESS;
9518 }
9519
9520 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9521 {
9522         int level;
9523         uint32_t _level;
9524         TALLOC_CTX *_mem_save_info1_0;
9525         TALLOC_CTX *_mem_save_info2_0;
9526         TALLOC_CTX *_mem_save_info3_0;
9527         TALLOC_CTX *_mem_save_info4_0;
9528         TALLOC_CTX *_mem_save_info6_0;
9529         TALLOC_CTX *_mem_save_info8_0;
9530         level = ndr_pull_get_switch_value(ndr, r);
9531         if (ndr_flags & NDR_SCALARS) {
9532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9533                 if (_level != level) {
9534                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9535                 }
9536                 switch (level) {
9537                         case 1: {
9538                                 uint32_t _ptr_info1;
9539                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9540                                 if (_ptr_info1) {
9541                                         NDR_PULL_ALLOC(ndr, r->info1);
9542                                 } else {
9543                                         r->info1 = NULL;
9544                                 }
9545                         break; }
9546
9547                         case 2: {
9548                                 uint32_t _ptr_info2;
9549                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9550                                 if (_ptr_info2) {
9551                                         NDR_PULL_ALLOC(ndr, r->info2);
9552                                 } else {
9553                                         r->info2 = NULL;
9554                                 }
9555                         break; }
9556
9557                         case 3: {
9558                                 uint32_t _ptr_info3;
9559                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9560                                 if (_ptr_info3) {
9561                                         NDR_PULL_ALLOC(ndr, r->info3);
9562                                 } else {
9563                                         r->info3 = NULL;
9564                                 }
9565                         break; }
9566
9567                         case 4: {
9568                                 uint32_t _ptr_info4;
9569                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9570                                 if (_ptr_info4) {
9571                                         NDR_PULL_ALLOC(ndr, r->info4);
9572                                 } else {
9573                                         r->info4 = NULL;
9574                                 }
9575                         break; }
9576
9577                         case 6: {
9578                                 uint32_t _ptr_info6;
9579                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9580                                 if (_ptr_info6) {
9581                                         NDR_PULL_ALLOC(ndr, r->info6);
9582                                 } else {
9583                                         r->info6 = NULL;
9584                                 }
9585                         break; }
9586
9587                         case 8: {
9588                                 uint32_t _ptr_info8;
9589                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9590                                 if (_ptr_info8) {
9591                                         NDR_PULL_ALLOC(ndr, r->info8);
9592                                 } else {
9593                                         r->info8 = NULL;
9594                                 }
9595                         break; }
9596
9597                         default:
9598                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9599                 }
9600         }
9601         if (ndr_flags & NDR_BUFFERS) {
9602                 switch (level) {
9603                         case 1:
9604                                 if (r->info1) {
9605                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9606                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9607                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9608                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9609                                 }
9610                         break;
9611
9612                         case 2:
9613                                 if (r->info2) {
9614                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9615                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9616                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9617                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9618                                 }
9619                         break;
9620
9621                         case 3:
9622                                 if (r->info3) {
9623                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9624                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9625                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9626                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9627                                 }
9628                         break;
9629
9630                         case 4:
9631                                 if (r->info4) {
9632                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9633                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9634                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9635                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9636                                 }
9637                         break;
9638
9639                         case 6:
9640                                 if (r->info6) {
9641                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9642                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9643                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9644                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9645                                 }
9646                         break;
9647
9648                         case 8:
9649                                 if (r->info8) {
9650                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9651                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9652                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9653                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9654                                 }
9655                         break;
9656
9657                         default:
9658                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9659                 }
9660         }
9661         return NDR_ERR_SUCCESS;
9662 }
9663
9664 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9665 {
9666         int level;
9667         level = ndr_print_get_switch_value(ndr, r);
9668         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9669         switch (level) {
9670                 case 1:
9671                         ndr_print_ptr(ndr, "info1", r->info1);
9672                         ndr->depth++;
9673                         if (r->info1) {
9674                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9675                         }
9676                         ndr->depth--;
9677                 break;
9678
9679                 case 2:
9680                         ndr_print_ptr(ndr, "info2", r->info2);
9681                         ndr->depth++;
9682                         if (r->info2) {
9683                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9684                         }
9685                         ndr->depth--;
9686                 break;
9687
9688                 case 3:
9689                         ndr_print_ptr(ndr, "info3", r->info3);
9690                         ndr->depth++;
9691                         if (r->info3) {
9692                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9693                         }
9694                         ndr->depth--;
9695                 break;
9696
9697                 case 4:
9698                         ndr_print_ptr(ndr, "info4", r->info4);
9699                         ndr->depth++;
9700                         if (r->info4) {
9701                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9702                         }
9703                         ndr->depth--;
9704                 break;
9705
9706                 case 6:
9707                         ndr_print_ptr(ndr, "info6", r->info6);
9708                         ndr->depth++;
9709                         if (r->info6) {
9710                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9711                         }
9712                         ndr->depth--;
9713                 break;
9714
9715                 case 8:
9716                         ndr_print_ptr(ndr, "info8", r->info8);
9717                         ndr->depth++;
9718                         if (r->info8) {
9719                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9720                         }
9721                         ndr->depth--;
9722                 break;
9723
9724                 default:
9725                         ndr_print_bad_level(ndr, name, level);
9726         }
9727 }
9728
9729 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9730 {
9731         if (ndr_flags & NDR_SCALARS) {
9732                 NDR_CHECK(ndr_push_align(ndr, 4));
9733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9734                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9735                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9736         }
9737         if (ndr_flags & NDR_BUFFERS) {
9738                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9739         }
9740         return NDR_ERR_SUCCESS;
9741 }
9742
9743 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9744 {
9745         if (ndr_flags & NDR_SCALARS) {
9746                 NDR_CHECK(ndr_pull_align(ndr, 4));
9747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9748                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9749                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9750         }
9751         if (ndr_flags & NDR_BUFFERS) {
9752                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9753         }
9754         return NDR_ERR_SUCCESS;
9755 }
9756
9757 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9758 {
9759         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9760         ndr->depth++;
9761         ndr_print_uint32(ndr, "level", r->level);
9762         ndr_print_set_switch_value(ndr, &r->info, r->level);
9763         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9764         ndr->depth--;
9765 }
9766
9767 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9768 {
9769         if (ndr_flags & NDR_SCALARS) {
9770                 NDR_CHECK(ndr_push_align(ndr, 4));
9771                 {
9772                         uint32_t _flags_save_string = ndr->flags;
9773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9774                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9775                         ndr->flags = _flags_save_string;
9776                 }
9777         }
9778         if (ndr_flags & NDR_BUFFERS) {
9779                 {
9780                         uint32_t _flags_save_string = ndr->flags;
9781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9782                         if (r->driver_name) {
9783                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9784                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9785                         }
9786                         ndr->flags = _flags_save_string;
9787                 }
9788         }
9789         return NDR_ERR_SUCCESS;
9790 }
9791
9792 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9793 {
9794         uint32_t _ptr_driver_name;
9795         TALLOC_CTX *_mem_save_driver_name_0;
9796         if (ndr_flags & NDR_SCALARS) {
9797                 NDR_CHECK(ndr_pull_align(ndr, 4));
9798                 {
9799                         uint32_t _flags_save_string = ndr->flags;
9800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9801                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9802                         if (_ptr_driver_name) {
9803                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9804                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9805                         } else {
9806                                 r->driver_name = NULL;
9807                         }
9808                         ndr->flags = _flags_save_string;
9809                 }
9810         }
9811         if (ndr_flags & NDR_BUFFERS) {
9812                 {
9813                         uint32_t _flags_save_string = ndr->flags;
9814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9815                         if (r->driver_name) {
9816                                 uint32_t _relative_save_offset;
9817                                 _relative_save_offset = ndr->offset;
9818                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9819                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9820                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9821                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9822                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9823                                 ndr->offset = _relative_save_offset;
9824                         }
9825                         ndr->flags = _flags_save_string;
9826                 }
9827         }
9828         return NDR_ERR_SUCCESS;
9829 }
9830
9831 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9832 {
9833         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9834         ndr->depth++;
9835         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9836         ndr->depth++;
9837         if (r->driver_name) {
9838                 ndr_print_string(ndr, "driver_name", r->driver_name);
9839         }
9840         ndr->depth--;
9841         ndr->depth--;
9842 }
9843
9844 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9845 {
9846         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9847 }
9848
9849 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9850 {
9851         if (ndr_flags & NDR_SCALARS) {
9852                 NDR_CHECK(ndr_push_align(ndr, 4));
9853                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9854                 {
9855                         uint32_t _flags_save_string = ndr->flags;
9856                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9857                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9858                         ndr->flags = _flags_save_string;
9859                 }
9860                 {
9861                         uint32_t _flags_save_string = ndr->flags;
9862                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9863                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9864                         ndr->flags = _flags_save_string;
9865                 }
9866                 {
9867                         uint32_t _flags_save_string = ndr->flags;
9868                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9869                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9870                         ndr->flags = _flags_save_string;
9871                 }
9872                 {
9873                         uint32_t _flags_save_string = ndr->flags;
9874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9875                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9876                         ndr->flags = _flags_save_string;
9877                 }
9878                 {
9879                         uint32_t _flags_save_string = ndr->flags;
9880                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9881                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9882                         ndr->flags = _flags_save_string;
9883                 }
9884         }
9885         if (ndr_flags & NDR_BUFFERS) {
9886                 {
9887                         uint32_t _flags_save_string = ndr->flags;
9888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9889                         if (r->driver_name) {
9890                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9891                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9892                         }
9893                         ndr->flags = _flags_save_string;
9894                 }
9895                 {
9896                         uint32_t _flags_save_string = ndr->flags;
9897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9898                         if (r->architecture) {
9899                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9900                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9901                         }
9902                         ndr->flags = _flags_save_string;
9903                 }
9904                 {
9905                         uint32_t _flags_save_string = ndr->flags;
9906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9907                         if (r->driver_path) {
9908                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9909                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9910                         }
9911                         ndr->flags = _flags_save_string;
9912                 }
9913                 {
9914                         uint32_t _flags_save_string = ndr->flags;
9915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9916                         if (r->data_file) {
9917                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9918                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9919                         }
9920                         ndr->flags = _flags_save_string;
9921                 }
9922                 {
9923                         uint32_t _flags_save_string = ndr->flags;
9924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9925                         if (r->config_file) {
9926                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9927                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9928                         }
9929                         ndr->flags = _flags_save_string;
9930                 }
9931         }
9932         return NDR_ERR_SUCCESS;
9933 }
9934
9935 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
9936 {
9937         uint32_t _ptr_driver_name;
9938         TALLOC_CTX *_mem_save_driver_name_0;
9939         uint32_t _ptr_architecture;
9940         TALLOC_CTX *_mem_save_architecture_0;
9941         uint32_t _ptr_driver_path;
9942         TALLOC_CTX *_mem_save_driver_path_0;
9943         uint32_t _ptr_data_file;
9944         TALLOC_CTX *_mem_save_data_file_0;
9945         uint32_t _ptr_config_file;
9946         TALLOC_CTX *_mem_save_config_file_0;
9947         if (ndr_flags & NDR_SCALARS) {
9948                 NDR_CHECK(ndr_pull_align(ndr, 4));
9949                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9950                 {
9951                         uint32_t _flags_save_string = ndr->flags;
9952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9953                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9954                         if (_ptr_driver_name) {
9955                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9956                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9957                         } else {
9958                                 r->driver_name = NULL;
9959                         }
9960                         ndr->flags = _flags_save_string;
9961                 }
9962                 {
9963                         uint32_t _flags_save_string = ndr->flags;
9964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9965                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9966                         if (_ptr_architecture) {
9967                                 NDR_PULL_ALLOC(ndr, r->architecture);
9968                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
9969                         } else {
9970                                 r->architecture = NULL;
9971                         }
9972                         ndr->flags = _flags_save_string;
9973                 }
9974                 {
9975                         uint32_t _flags_save_string = ndr->flags;
9976                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9977                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9978                         if (_ptr_driver_path) {
9979                                 NDR_PULL_ALLOC(ndr, r->driver_path);
9980                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
9981                         } else {
9982                                 r->driver_path = NULL;
9983                         }
9984                         ndr->flags = _flags_save_string;
9985                 }
9986                 {
9987                         uint32_t _flags_save_string = ndr->flags;
9988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9989                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9990                         if (_ptr_data_file) {
9991                                 NDR_PULL_ALLOC(ndr, r->data_file);
9992                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
9993                         } else {
9994                                 r->data_file = NULL;
9995                         }
9996                         ndr->flags = _flags_save_string;
9997                 }
9998                 {
9999                         uint32_t _flags_save_string = ndr->flags;
10000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10001                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10002                         if (_ptr_config_file) {
10003                                 NDR_PULL_ALLOC(ndr, r->config_file);
10004                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10005                         } else {
10006                                 r->config_file = NULL;
10007                         }
10008                         ndr->flags = _flags_save_string;
10009                 }
10010         }
10011         if (ndr_flags & NDR_BUFFERS) {
10012                 {
10013                         uint32_t _flags_save_string = ndr->flags;
10014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10015                         if (r->driver_name) {
10016                                 uint32_t _relative_save_offset;
10017                                 _relative_save_offset = ndr->offset;
10018                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10019                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10020                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10021                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10022                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10023                                 ndr->offset = _relative_save_offset;
10024                         }
10025                         ndr->flags = _flags_save_string;
10026                 }
10027                 {
10028                         uint32_t _flags_save_string = ndr->flags;
10029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10030                         if (r->architecture) {
10031                                 uint32_t _relative_save_offset;
10032                                 _relative_save_offset = ndr->offset;
10033                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10034                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10035                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10036                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10037                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10038                                 ndr->offset = _relative_save_offset;
10039                         }
10040                         ndr->flags = _flags_save_string;
10041                 }
10042                 {
10043                         uint32_t _flags_save_string = ndr->flags;
10044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10045                         if (r->driver_path) {
10046                                 uint32_t _relative_save_offset;
10047                                 _relative_save_offset = ndr->offset;
10048                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10049                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10050                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10051                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10052                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10053                                 ndr->offset = _relative_save_offset;
10054                         }
10055                         ndr->flags = _flags_save_string;
10056                 }
10057                 {
10058                         uint32_t _flags_save_string = ndr->flags;
10059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10060                         if (r->data_file) {
10061                                 uint32_t _relative_save_offset;
10062                                 _relative_save_offset = ndr->offset;
10063                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10064                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10065                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10066                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10067                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10068                                 ndr->offset = _relative_save_offset;
10069                         }
10070                         ndr->flags = _flags_save_string;
10071                 }
10072                 {
10073                         uint32_t _flags_save_string = ndr->flags;
10074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10075                         if (r->config_file) {
10076                                 uint32_t _relative_save_offset;
10077                                 _relative_save_offset = ndr->offset;
10078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10079                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10080                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10083                                 ndr->offset = _relative_save_offset;
10084                         }
10085                         ndr->flags = _flags_save_string;
10086                 }
10087         }
10088         return NDR_ERR_SUCCESS;
10089 }
10090
10091 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10092 {
10093         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10094         ndr->depth++;
10095         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10096         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10097         ndr->depth++;
10098         if (r->driver_name) {
10099                 ndr_print_string(ndr, "driver_name", r->driver_name);
10100         }
10101         ndr->depth--;
10102         ndr_print_ptr(ndr, "architecture", r->architecture);
10103         ndr->depth++;
10104         if (r->architecture) {
10105                 ndr_print_string(ndr, "architecture", r->architecture);
10106         }
10107         ndr->depth--;
10108         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10109         ndr->depth++;
10110         if (r->driver_path) {
10111                 ndr_print_string(ndr, "driver_path", r->driver_path);
10112         }
10113         ndr->depth--;
10114         ndr_print_ptr(ndr, "data_file", r->data_file);
10115         ndr->depth++;
10116         if (r->data_file) {
10117                 ndr_print_string(ndr, "data_file", r->data_file);
10118         }
10119         ndr->depth--;
10120         ndr_print_ptr(ndr, "config_file", r->config_file);
10121         ndr->depth++;
10122         if (r->config_file) {
10123                 ndr_print_string(ndr, "config_file", r->config_file);
10124         }
10125         ndr->depth--;
10126         ndr->depth--;
10127 }
10128
10129 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10130 {
10131         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10132 }
10133
10134 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10135 {
10136         if (ndr_flags & NDR_SCALARS) {
10137                 NDR_CHECK(ndr_push_align(ndr, 4));
10138                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10139                 {
10140                         uint32_t _flags_save_string = ndr->flags;
10141                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10142                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10143                         ndr->flags = _flags_save_string;
10144                 }
10145                 {
10146                         uint32_t _flags_save_string = ndr->flags;
10147                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10148                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10149                         ndr->flags = _flags_save_string;
10150                 }
10151                 {
10152                         uint32_t _flags_save_string = ndr->flags;
10153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10154                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10155                         ndr->flags = _flags_save_string;
10156                 }
10157                 {
10158                         uint32_t _flags_save_string = ndr->flags;
10159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10160                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10161                         ndr->flags = _flags_save_string;
10162                 }
10163                 {
10164                         uint32_t _flags_save_string = ndr->flags;
10165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10166                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10167                         ndr->flags = _flags_save_string;
10168                 }
10169                 {
10170                         uint32_t _flags_save_string = ndr->flags;
10171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10172                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10173                         ndr->flags = _flags_save_string;
10174                 }
10175                 {
10176                         uint32_t _flags_save_string_array = ndr->flags;
10177                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10178                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10179                         ndr->flags = _flags_save_string_array;
10180                 }
10181                 {
10182                         uint32_t _flags_save_string = ndr->flags;
10183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10184                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10185                         ndr->flags = _flags_save_string;
10186                 }
10187                 {
10188                         uint32_t _flags_save_string = ndr->flags;
10189                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10190                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10191                         ndr->flags = _flags_save_string;
10192                 }
10193         }
10194         if (ndr_flags & NDR_BUFFERS) {
10195                 {
10196                         uint32_t _flags_save_string = ndr->flags;
10197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10198                         if (r->driver_name) {
10199                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10200                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10201                         }
10202                         ndr->flags = _flags_save_string;
10203                 }
10204                 {
10205                         uint32_t _flags_save_string = ndr->flags;
10206                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10207                         if (r->architecture) {
10208                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10209                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10210                         }
10211                         ndr->flags = _flags_save_string;
10212                 }
10213                 {
10214                         uint32_t _flags_save_string = ndr->flags;
10215                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10216                         if (r->driver_path) {
10217                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10218                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10219                         }
10220                         ndr->flags = _flags_save_string;
10221                 }
10222                 {
10223                         uint32_t _flags_save_string = ndr->flags;
10224                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10225                         if (r->data_file) {
10226                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10227                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10228                         }
10229                         ndr->flags = _flags_save_string;
10230                 }
10231                 {
10232                         uint32_t _flags_save_string = ndr->flags;
10233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10234                         if (r->config_file) {
10235                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10236                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10237                         }
10238                         ndr->flags = _flags_save_string;
10239                 }
10240                 {
10241                         uint32_t _flags_save_string = ndr->flags;
10242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10243                         if (r->help_file) {
10244                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10245                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10246                         }
10247                         ndr->flags = _flags_save_string;
10248                 }
10249                 {
10250                         uint32_t _flags_save_string_array = ndr->flags;
10251                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10252                         if (r->dependent_files) {
10253                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10254                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10255                         }
10256                         ndr->flags = _flags_save_string_array;
10257                 }
10258                 {
10259                         uint32_t _flags_save_string = ndr->flags;
10260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10261                         if (r->monitor_name) {
10262                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10263                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10264                         }
10265                         ndr->flags = _flags_save_string;
10266                 }
10267                 {
10268                         uint32_t _flags_save_string = ndr->flags;
10269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10270                         if (r->default_datatype) {
10271                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10272                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10273                         }
10274                         ndr->flags = _flags_save_string;
10275                 }
10276         }
10277         return NDR_ERR_SUCCESS;
10278 }
10279
10280 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10281 {
10282         uint32_t _ptr_driver_name;
10283         TALLOC_CTX *_mem_save_driver_name_0;
10284         uint32_t _ptr_architecture;
10285         TALLOC_CTX *_mem_save_architecture_0;
10286         uint32_t _ptr_driver_path;
10287         TALLOC_CTX *_mem_save_driver_path_0;
10288         uint32_t _ptr_data_file;
10289         TALLOC_CTX *_mem_save_data_file_0;
10290         uint32_t _ptr_config_file;
10291         TALLOC_CTX *_mem_save_config_file_0;
10292         uint32_t _ptr_help_file;
10293         TALLOC_CTX *_mem_save_help_file_0;
10294         uint32_t _ptr_dependent_files;
10295         TALLOC_CTX *_mem_save_dependent_files_0;
10296         uint32_t _ptr_monitor_name;
10297         TALLOC_CTX *_mem_save_monitor_name_0;
10298         uint32_t _ptr_default_datatype;
10299         TALLOC_CTX *_mem_save_default_datatype_0;
10300         if (ndr_flags & NDR_SCALARS) {
10301                 NDR_CHECK(ndr_pull_align(ndr, 4));
10302                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10303                 {
10304                         uint32_t _flags_save_string = ndr->flags;
10305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10306                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10307                         if (_ptr_driver_name) {
10308                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10309                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10310                         } else {
10311                                 r->driver_name = NULL;
10312                         }
10313                         ndr->flags = _flags_save_string;
10314                 }
10315                 {
10316                         uint32_t _flags_save_string = ndr->flags;
10317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10318                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10319                         if (_ptr_architecture) {
10320                                 NDR_PULL_ALLOC(ndr, r->architecture);
10321                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10322                         } else {
10323                                 r->architecture = NULL;
10324                         }
10325                         ndr->flags = _flags_save_string;
10326                 }
10327                 {
10328                         uint32_t _flags_save_string = ndr->flags;
10329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10330                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10331                         if (_ptr_driver_path) {
10332                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10333                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10334                         } else {
10335                                 r->driver_path = NULL;
10336                         }
10337                         ndr->flags = _flags_save_string;
10338                 }
10339                 {
10340                         uint32_t _flags_save_string = ndr->flags;
10341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10343                         if (_ptr_data_file) {
10344                                 NDR_PULL_ALLOC(ndr, r->data_file);
10345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10346                         } else {
10347                                 r->data_file = NULL;
10348                         }
10349                         ndr->flags = _flags_save_string;
10350                 }
10351                 {
10352                         uint32_t _flags_save_string = ndr->flags;
10353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10355                         if (_ptr_config_file) {
10356                                 NDR_PULL_ALLOC(ndr, r->config_file);
10357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10358                         } else {
10359                                 r->config_file = NULL;
10360                         }
10361                         ndr->flags = _flags_save_string;
10362                 }
10363                 {
10364                         uint32_t _flags_save_string = ndr->flags;
10365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10366                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10367                         if (_ptr_help_file) {
10368                                 NDR_PULL_ALLOC(ndr, r->help_file);
10369                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10370                         } else {
10371                                 r->help_file = NULL;
10372                         }
10373                         ndr->flags = _flags_save_string;
10374                 }
10375                 {
10376                         uint32_t _flags_save_string_array = ndr->flags;
10377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10378                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10379                         if (_ptr_dependent_files) {
10380                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10381                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10382                         } else {
10383                                 r->dependent_files = NULL;
10384                         }
10385                         ndr->flags = _flags_save_string_array;
10386                 }
10387                 {
10388                         uint32_t _flags_save_string = ndr->flags;
10389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10390                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10391                         if (_ptr_monitor_name) {
10392                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10393                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10394                         } else {
10395                                 r->monitor_name = NULL;
10396                         }
10397                         ndr->flags = _flags_save_string;
10398                 }
10399                 {
10400                         uint32_t _flags_save_string = ndr->flags;
10401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10402                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10403                         if (_ptr_default_datatype) {
10404                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10405                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10406                         } else {
10407                                 r->default_datatype = NULL;
10408                         }
10409                         ndr->flags = _flags_save_string;
10410                 }
10411         }
10412         if (ndr_flags & NDR_BUFFERS) {
10413                 {
10414                         uint32_t _flags_save_string = ndr->flags;
10415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10416                         if (r->driver_name) {
10417                                 uint32_t _relative_save_offset;
10418                                 _relative_save_offset = ndr->offset;
10419                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10420                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10421                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10422                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10423                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10424                                 ndr->offset = _relative_save_offset;
10425                         }
10426                         ndr->flags = _flags_save_string;
10427                 }
10428                 {
10429                         uint32_t _flags_save_string = ndr->flags;
10430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10431                         if (r->architecture) {
10432                                 uint32_t _relative_save_offset;
10433                                 _relative_save_offset = ndr->offset;
10434                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10435                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10436                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10437                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10438                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10439                                 ndr->offset = _relative_save_offset;
10440                         }
10441                         ndr->flags = _flags_save_string;
10442                 }
10443                 {
10444                         uint32_t _flags_save_string = ndr->flags;
10445                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10446                         if (r->driver_path) {
10447                                 uint32_t _relative_save_offset;
10448                                 _relative_save_offset = ndr->offset;
10449                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10450                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10451                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10452                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10453                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10454                                 ndr->offset = _relative_save_offset;
10455                         }
10456                         ndr->flags = _flags_save_string;
10457                 }
10458                 {
10459                         uint32_t _flags_save_string = ndr->flags;
10460                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10461                         if (r->data_file) {
10462                                 uint32_t _relative_save_offset;
10463                                 _relative_save_offset = ndr->offset;
10464                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10465                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10466                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10467                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10468                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10469                                 ndr->offset = _relative_save_offset;
10470                         }
10471                         ndr->flags = _flags_save_string;
10472                 }
10473                 {
10474                         uint32_t _flags_save_string = ndr->flags;
10475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10476                         if (r->config_file) {
10477                                 uint32_t _relative_save_offset;
10478                                 _relative_save_offset = ndr->offset;
10479                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10480                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10481                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10482                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10483                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10484                                 ndr->offset = _relative_save_offset;
10485                         }
10486                         ndr->flags = _flags_save_string;
10487                 }
10488                 {
10489                         uint32_t _flags_save_string = ndr->flags;
10490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10491                         if (r->help_file) {
10492                                 uint32_t _relative_save_offset;
10493                                 _relative_save_offset = ndr->offset;
10494                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10495                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10496                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10497                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10498                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10499                                 ndr->offset = _relative_save_offset;
10500                         }
10501                         ndr->flags = _flags_save_string;
10502                 }
10503                 {
10504                         uint32_t _flags_save_string_array = ndr->flags;
10505                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10506                         if (r->dependent_files) {
10507                                 uint32_t _relative_save_offset;
10508                                 _relative_save_offset = ndr->offset;
10509                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10510                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10511                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10512                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10513                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10514                                 ndr->offset = _relative_save_offset;
10515                         }
10516                         ndr->flags = _flags_save_string_array;
10517                 }
10518                 {
10519                         uint32_t _flags_save_string = ndr->flags;
10520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10521                         if (r->monitor_name) {
10522                                 uint32_t _relative_save_offset;
10523                                 _relative_save_offset = ndr->offset;
10524                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10525                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10526                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10527                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10528                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10529                                 ndr->offset = _relative_save_offset;
10530                         }
10531                         ndr->flags = _flags_save_string;
10532                 }
10533                 {
10534                         uint32_t _flags_save_string = ndr->flags;
10535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10536                         if (r->default_datatype) {
10537                                 uint32_t _relative_save_offset;
10538                                 _relative_save_offset = ndr->offset;
10539                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10540                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10541                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10542                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10543                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10544                                 ndr->offset = _relative_save_offset;
10545                         }
10546                         ndr->flags = _flags_save_string;
10547                 }
10548         }
10549         return NDR_ERR_SUCCESS;
10550 }
10551
10552 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10553 {
10554         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10555         ndr->depth++;
10556         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10557         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10558         ndr->depth++;
10559         if (r->driver_name) {
10560                 ndr_print_string(ndr, "driver_name", r->driver_name);
10561         }
10562         ndr->depth--;
10563         ndr_print_ptr(ndr, "architecture", r->architecture);
10564         ndr->depth++;
10565         if (r->architecture) {
10566                 ndr_print_string(ndr, "architecture", r->architecture);
10567         }
10568         ndr->depth--;
10569         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10570         ndr->depth++;
10571         if (r->driver_path) {
10572                 ndr_print_string(ndr, "driver_path", r->driver_path);
10573         }
10574         ndr->depth--;
10575         ndr_print_ptr(ndr, "data_file", r->data_file);
10576         ndr->depth++;
10577         if (r->data_file) {
10578                 ndr_print_string(ndr, "data_file", r->data_file);
10579         }
10580         ndr->depth--;
10581         ndr_print_ptr(ndr, "config_file", r->config_file);
10582         ndr->depth++;
10583         if (r->config_file) {
10584                 ndr_print_string(ndr, "config_file", r->config_file);
10585         }
10586         ndr->depth--;
10587         ndr_print_ptr(ndr, "help_file", r->help_file);
10588         ndr->depth++;
10589         if (r->help_file) {
10590                 ndr_print_string(ndr, "help_file", r->help_file);
10591         }
10592         ndr->depth--;
10593         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10594         ndr->depth++;
10595         if (r->dependent_files) {
10596                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10597         }
10598         ndr->depth--;
10599         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10600         ndr->depth++;
10601         if (r->monitor_name) {
10602                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10603         }
10604         ndr->depth--;
10605         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10606         ndr->depth++;
10607         if (r->default_datatype) {
10608                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10609         }
10610         ndr->depth--;
10611         ndr->depth--;
10612 }
10613
10614 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10615 {
10616         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10617 }
10618
10619 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10620 {
10621         if (ndr_flags & NDR_SCALARS) {
10622                 NDR_CHECK(ndr_push_align(ndr, 4));
10623                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10624                 {
10625                         uint32_t _flags_save_string = ndr->flags;
10626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10627                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10628                         ndr->flags = _flags_save_string;
10629                 }
10630                 {
10631                         uint32_t _flags_save_string = ndr->flags;
10632                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10633                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10634                         ndr->flags = _flags_save_string;
10635                 }
10636                 {
10637                         uint32_t _flags_save_string = ndr->flags;
10638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10639                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10640                         ndr->flags = _flags_save_string;
10641                 }
10642                 {
10643                         uint32_t _flags_save_string = ndr->flags;
10644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10645                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10646                         ndr->flags = _flags_save_string;
10647                 }
10648                 {
10649                         uint32_t _flags_save_string = ndr->flags;
10650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10651                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10652                         ndr->flags = _flags_save_string;
10653                 }
10654                 {
10655                         uint32_t _flags_save_string = ndr->flags;
10656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10657                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10658                         ndr->flags = _flags_save_string;
10659                 }
10660                 {
10661                         uint32_t _flags_save_string_array = ndr->flags;
10662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10663                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10664                         ndr->flags = _flags_save_string_array;
10665                 }
10666                 {
10667                         uint32_t _flags_save_string = ndr->flags;
10668                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10669                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10670                         ndr->flags = _flags_save_string;
10671                 }
10672                 {
10673                         uint32_t _flags_save_string = ndr->flags;
10674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10675                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10676                         ndr->flags = _flags_save_string;
10677                 }
10678                 {
10679                         uint32_t _flags_save_string_array = ndr->flags;
10680                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10681                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10682                         ndr->flags = _flags_save_string_array;
10683                 }
10684         }
10685         if (ndr_flags & NDR_BUFFERS) {
10686                 {
10687                         uint32_t _flags_save_string = ndr->flags;
10688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10689                         if (r->driver_name) {
10690                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10691                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10692                         }
10693                         ndr->flags = _flags_save_string;
10694                 }
10695                 {
10696                         uint32_t _flags_save_string = ndr->flags;
10697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10698                         if (r->architecture) {
10699                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10700                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10701                         }
10702                         ndr->flags = _flags_save_string;
10703                 }
10704                 {
10705                         uint32_t _flags_save_string = ndr->flags;
10706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10707                         if (r->driver_path) {
10708                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10710                         }
10711                         ndr->flags = _flags_save_string;
10712                 }
10713                 {
10714                         uint32_t _flags_save_string = ndr->flags;
10715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10716                         if (r->data_file) {
10717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10718                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10719                         }
10720                         ndr->flags = _flags_save_string;
10721                 }
10722                 {
10723                         uint32_t _flags_save_string = ndr->flags;
10724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10725                         if (r->config_file) {
10726                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10727                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10728                         }
10729                         ndr->flags = _flags_save_string;
10730                 }
10731                 {
10732                         uint32_t _flags_save_string = ndr->flags;
10733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10734                         if (r->help_file) {
10735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10736                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10737                         }
10738                         ndr->flags = _flags_save_string;
10739                 }
10740                 {
10741                         uint32_t _flags_save_string_array = ndr->flags;
10742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10743                         if (r->dependent_files) {
10744                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10745                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10746                         }
10747                         ndr->flags = _flags_save_string_array;
10748                 }
10749                 {
10750                         uint32_t _flags_save_string = ndr->flags;
10751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10752                         if (r->monitor_name) {
10753                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10754                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10755                         }
10756                         ndr->flags = _flags_save_string;
10757                 }
10758                 {
10759                         uint32_t _flags_save_string = ndr->flags;
10760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10761                         if (r->default_datatype) {
10762                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10763                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10764                         }
10765                         ndr->flags = _flags_save_string;
10766                 }
10767                 {
10768                         uint32_t _flags_save_string_array = ndr->flags;
10769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10770                         if (r->previous_names) {
10771                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10772                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10773                         }
10774                         ndr->flags = _flags_save_string_array;
10775                 }
10776         }
10777         return NDR_ERR_SUCCESS;
10778 }
10779
10780 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10781 {
10782         uint32_t _ptr_driver_name;
10783         TALLOC_CTX *_mem_save_driver_name_0;
10784         uint32_t _ptr_architecture;
10785         TALLOC_CTX *_mem_save_architecture_0;
10786         uint32_t _ptr_driver_path;
10787         TALLOC_CTX *_mem_save_driver_path_0;
10788         uint32_t _ptr_data_file;
10789         TALLOC_CTX *_mem_save_data_file_0;
10790         uint32_t _ptr_config_file;
10791         TALLOC_CTX *_mem_save_config_file_0;
10792         uint32_t _ptr_help_file;
10793         TALLOC_CTX *_mem_save_help_file_0;
10794         uint32_t _ptr_dependent_files;
10795         TALLOC_CTX *_mem_save_dependent_files_0;
10796         uint32_t _ptr_monitor_name;
10797         TALLOC_CTX *_mem_save_monitor_name_0;
10798         uint32_t _ptr_default_datatype;
10799         TALLOC_CTX *_mem_save_default_datatype_0;
10800         uint32_t _ptr_previous_names;
10801         TALLOC_CTX *_mem_save_previous_names_0;
10802         if (ndr_flags & NDR_SCALARS) {
10803                 NDR_CHECK(ndr_pull_align(ndr, 4));
10804                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10805                 {
10806                         uint32_t _flags_save_string = ndr->flags;
10807                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10808                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10809                         if (_ptr_driver_name) {
10810                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10811                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10812                         } else {
10813                                 r->driver_name = NULL;
10814                         }
10815                         ndr->flags = _flags_save_string;
10816                 }
10817                 {
10818                         uint32_t _flags_save_string = ndr->flags;
10819                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10820                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10821                         if (_ptr_architecture) {
10822                                 NDR_PULL_ALLOC(ndr, r->architecture);
10823                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10824                         } else {
10825                                 r->architecture = NULL;
10826                         }
10827                         ndr->flags = _flags_save_string;
10828                 }
10829                 {
10830                         uint32_t _flags_save_string = ndr->flags;
10831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10832                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10833                         if (_ptr_driver_path) {
10834                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10835                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10836                         } else {
10837                                 r->driver_path = NULL;
10838                         }
10839                         ndr->flags = _flags_save_string;
10840                 }
10841                 {
10842                         uint32_t _flags_save_string = ndr->flags;
10843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10844                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10845                         if (_ptr_data_file) {
10846                                 NDR_PULL_ALLOC(ndr, r->data_file);
10847                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10848                         } else {
10849                                 r->data_file = NULL;
10850                         }
10851                         ndr->flags = _flags_save_string;
10852                 }
10853                 {
10854                         uint32_t _flags_save_string = ndr->flags;
10855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10856                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10857                         if (_ptr_config_file) {
10858                                 NDR_PULL_ALLOC(ndr, r->config_file);
10859                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10860                         } else {
10861                                 r->config_file = NULL;
10862                         }
10863                         ndr->flags = _flags_save_string;
10864                 }
10865                 {
10866                         uint32_t _flags_save_string = ndr->flags;
10867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10868                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10869                         if (_ptr_help_file) {
10870                                 NDR_PULL_ALLOC(ndr, r->help_file);
10871                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10872                         } else {
10873                                 r->help_file = NULL;
10874                         }
10875                         ndr->flags = _flags_save_string;
10876                 }
10877                 {
10878                         uint32_t _flags_save_string_array = ndr->flags;
10879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10880                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10881                         if (_ptr_dependent_files) {
10882                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10883                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10884                         } else {
10885                                 r->dependent_files = NULL;
10886                         }
10887                         ndr->flags = _flags_save_string_array;
10888                 }
10889                 {
10890                         uint32_t _flags_save_string = ndr->flags;
10891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10892                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10893                         if (_ptr_monitor_name) {
10894                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10895                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10896                         } else {
10897                                 r->monitor_name = NULL;
10898                         }
10899                         ndr->flags = _flags_save_string;
10900                 }
10901                 {
10902                         uint32_t _flags_save_string = ndr->flags;
10903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10905                         if (_ptr_default_datatype) {
10906                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10907                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10908                         } else {
10909                                 r->default_datatype = NULL;
10910                         }
10911                         ndr->flags = _flags_save_string;
10912                 }
10913                 {
10914                         uint32_t _flags_save_string_array = ndr->flags;
10915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10916                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10917                         if (_ptr_previous_names) {
10918                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10919                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10920                         } else {
10921                                 r->previous_names = NULL;
10922                         }
10923                         ndr->flags = _flags_save_string_array;
10924                 }
10925         }
10926         if (ndr_flags & NDR_BUFFERS) {
10927                 {
10928                         uint32_t _flags_save_string = ndr->flags;
10929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10930                         if (r->driver_name) {
10931                                 uint32_t _relative_save_offset;
10932                                 _relative_save_offset = ndr->offset;
10933                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10934                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10935                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10936                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10937                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10938                                 ndr->offset = _relative_save_offset;
10939                         }
10940                         ndr->flags = _flags_save_string;
10941                 }
10942                 {
10943                         uint32_t _flags_save_string = ndr->flags;
10944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10945                         if (r->architecture) {
10946                                 uint32_t _relative_save_offset;
10947                                 _relative_save_offset = ndr->offset;
10948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10949                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10950                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10953                                 ndr->offset = _relative_save_offset;
10954                         }
10955                         ndr->flags = _flags_save_string;
10956                 }
10957                 {
10958                         uint32_t _flags_save_string = ndr->flags;
10959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10960                         if (r->driver_path) {
10961                                 uint32_t _relative_save_offset;
10962                                 _relative_save_offset = ndr->offset;
10963                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10964                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10965                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10966                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10967                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10968                                 ndr->offset = _relative_save_offset;
10969                         }
10970                         ndr->flags = _flags_save_string;
10971                 }
10972                 {
10973                         uint32_t _flags_save_string = ndr->flags;
10974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10975                         if (r->data_file) {
10976                                 uint32_t _relative_save_offset;
10977                                 _relative_save_offset = ndr->offset;
10978                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10979                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10980                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10981                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10982                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10983                                 ndr->offset = _relative_save_offset;
10984                         }
10985                         ndr->flags = _flags_save_string;
10986                 }
10987                 {
10988                         uint32_t _flags_save_string = ndr->flags;
10989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10990                         if (r->config_file) {
10991                                 uint32_t _relative_save_offset;
10992                                 _relative_save_offset = ndr->offset;
10993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10994                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10995                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10998                                 ndr->offset = _relative_save_offset;
10999                         }
11000                         ndr->flags = _flags_save_string;
11001                 }
11002                 {
11003                         uint32_t _flags_save_string = ndr->flags;
11004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11005                         if (r->help_file) {
11006                                 uint32_t _relative_save_offset;
11007                                 _relative_save_offset = ndr->offset;
11008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11009                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11010                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11013                                 ndr->offset = _relative_save_offset;
11014                         }
11015                         ndr->flags = _flags_save_string;
11016                 }
11017                 {
11018                         uint32_t _flags_save_string_array = ndr->flags;
11019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11020                         if (r->dependent_files) {
11021                                 uint32_t _relative_save_offset;
11022                                 _relative_save_offset = ndr->offset;
11023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11024                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11025                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11026                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11028                                 ndr->offset = _relative_save_offset;
11029                         }
11030                         ndr->flags = _flags_save_string_array;
11031                 }
11032                 {
11033                         uint32_t _flags_save_string = ndr->flags;
11034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11035                         if (r->monitor_name) {
11036                                 uint32_t _relative_save_offset;
11037                                 _relative_save_offset = ndr->offset;
11038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11039                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11040                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11043                                 ndr->offset = _relative_save_offset;
11044                         }
11045                         ndr->flags = _flags_save_string;
11046                 }
11047                 {
11048                         uint32_t _flags_save_string = ndr->flags;
11049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11050                         if (r->default_datatype) {
11051                                 uint32_t _relative_save_offset;
11052                                 _relative_save_offset = ndr->offset;
11053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11054                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11055                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11058                                 ndr->offset = _relative_save_offset;
11059                         }
11060                         ndr->flags = _flags_save_string;
11061                 }
11062                 {
11063                         uint32_t _flags_save_string_array = ndr->flags;
11064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11065                         if (r->previous_names) {
11066                                 uint32_t _relative_save_offset;
11067                                 _relative_save_offset = ndr->offset;
11068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11069                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11070                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11071                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11073                                 ndr->offset = _relative_save_offset;
11074                         }
11075                         ndr->flags = _flags_save_string_array;
11076                 }
11077         }
11078         return NDR_ERR_SUCCESS;
11079 }
11080
11081 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11082 {
11083         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11084         ndr->depth++;
11085         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11086         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11087         ndr->depth++;
11088         if (r->driver_name) {
11089                 ndr_print_string(ndr, "driver_name", r->driver_name);
11090         }
11091         ndr->depth--;
11092         ndr_print_ptr(ndr, "architecture", r->architecture);
11093         ndr->depth++;
11094         if (r->architecture) {
11095                 ndr_print_string(ndr, "architecture", r->architecture);
11096         }
11097         ndr->depth--;
11098         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11099         ndr->depth++;
11100         if (r->driver_path) {
11101                 ndr_print_string(ndr, "driver_path", r->driver_path);
11102         }
11103         ndr->depth--;
11104         ndr_print_ptr(ndr, "data_file", r->data_file);
11105         ndr->depth++;
11106         if (r->data_file) {
11107                 ndr_print_string(ndr, "data_file", r->data_file);
11108         }
11109         ndr->depth--;
11110         ndr_print_ptr(ndr, "config_file", r->config_file);
11111         ndr->depth++;
11112         if (r->config_file) {
11113                 ndr_print_string(ndr, "config_file", r->config_file);
11114         }
11115         ndr->depth--;
11116         ndr_print_ptr(ndr, "help_file", r->help_file);
11117         ndr->depth++;
11118         if (r->help_file) {
11119                 ndr_print_string(ndr, "help_file", r->help_file);
11120         }
11121         ndr->depth--;
11122         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11123         ndr->depth++;
11124         if (r->dependent_files) {
11125                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11126         }
11127         ndr->depth--;
11128         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11129         ndr->depth++;
11130         if (r->monitor_name) {
11131                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11132         }
11133         ndr->depth--;
11134         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11135         ndr->depth++;
11136         if (r->default_datatype) {
11137                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11138         }
11139         ndr->depth--;
11140         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11141         ndr->depth++;
11142         if (r->previous_names) {
11143                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11144         }
11145         ndr->depth--;
11146         ndr->depth--;
11147 }
11148
11149 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11150 {
11151         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11152 }
11153
11154 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11155 {
11156         if (ndr_flags & NDR_SCALARS) {
11157                 NDR_CHECK(ndr_push_align(ndr, 4));
11158                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11159                 {
11160                         uint32_t _flags_save_string = ndr->flags;
11161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11162                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11163                         ndr->flags = _flags_save_string;
11164                 }
11165                 {
11166                         uint32_t _flags_save_string = ndr->flags;
11167                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11168                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11169                         ndr->flags = _flags_save_string;
11170                 }
11171                 {
11172                         uint32_t _flags_save_string = ndr->flags;
11173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11174                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11175                         ndr->flags = _flags_save_string;
11176                 }
11177                 {
11178                         uint32_t _flags_save_string = ndr->flags;
11179                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11180                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11181                         ndr->flags = _flags_save_string;
11182                 }
11183                 {
11184                         uint32_t _flags_save_string = ndr->flags;
11185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11186                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11187                         ndr->flags = _flags_save_string;
11188                 }
11189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
11190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11192         }
11193         if (ndr_flags & NDR_BUFFERS) {
11194                 {
11195                         uint32_t _flags_save_string = ndr->flags;
11196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11197                         if (r->driver_name) {
11198                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11199                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11200                         }
11201                         ndr->flags = _flags_save_string;
11202                 }
11203                 {
11204                         uint32_t _flags_save_string = ndr->flags;
11205                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11206                         if (r->architecture) {
11207                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11208                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11209                         }
11210                         ndr->flags = _flags_save_string;
11211                 }
11212                 {
11213                         uint32_t _flags_save_string = ndr->flags;
11214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11215                         if (r->driver_path) {
11216                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11217                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11218                         }
11219                         ndr->flags = _flags_save_string;
11220                 }
11221                 {
11222                         uint32_t _flags_save_string = ndr->flags;
11223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11224                         if (r->data_file) {
11225                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11226                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11227                         }
11228                         ndr->flags = _flags_save_string;
11229                 }
11230                 {
11231                         uint32_t _flags_save_string = ndr->flags;
11232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11233                         if (r->config_file) {
11234                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11235                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11236                         }
11237                         ndr->flags = _flags_save_string;
11238                 }
11239         }
11240         return NDR_ERR_SUCCESS;
11241 }
11242
11243 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11244 {
11245         uint32_t _ptr_driver_name;
11246         TALLOC_CTX *_mem_save_driver_name_0;
11247         uint32_t _ptr_architecture;
11248         TALLOC_CTX *_mem_save_architecture_0;
11249         uint32_t _ptr_driver_path;
11250         TALLOC_CTX *_mem_save_driver_path_0;
11251         uint32_t _ptr_data_file;
11252         TALLOC_CTX *_mem_save_data_file_0;
11253         uint32_t _ptr_config_file;
11254         TALLOC_CTX *_mem_save_config_file_0;
11255         if (ndr_flags & NDR_SCALARS) {
11256                 NDR_CHECK(ndr_pull_align(ndr, 4));
11257                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11258                 {
11259                         uint32_t _flags_save_string = ndr->flags;
11260                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11261                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11262                         if (_ptr_driver_name) {
11263                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11264                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11265                         } else {
11266                                 r->driver_name = NULL;
11267                         }
11268                         ndr->flags = _flags_save_string;
11269                 }
11270                 {
11271                         uint32_t _flags_save_string = ndr->flags;
11272                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11273                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11274                         if (_ptr_architecture) {
11275                                 NDR_PULL_ALLOC(ndr, r->architecture);
11276                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11277                         } else {
11278                                 r->architecture = NULL;
11279                         }
11280                         ndr->flags = _flags_save_string;
11281                 }
11282                 {
11283                         uint32_t _flags_save_string = ndr->flags;
11284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11285                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11286                         if (_ptr_driver_path) {
11287                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11288                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11289                         } else {
11290                                 r->driver_path = NULL;
11291                         }
11292                         ndr->flags = _flags_save_string;
11293                 }
11294                 {
11295                         uint32_t _flags_save_string = ndr->flags;
11296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11297                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11298                         if (_ptr_data_file) {
11299                                 NDR_PULL_ALLOC(ndr, r->data_file);
11300                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11301                         } else {
11302                                 r->data_file = NULL;
11303                         }
11304                         ndr->flags = _flags_save_string;
11305                 }
11306                 {
11307                         uint32_t _flags_save_string = ndr->flags;
11308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11309                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11310                         if (_ptr_config_file) {
11311                                 NDR_PULL_ALLOC(ndr, r->config_file);
11312                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11313                         } else {
11314                                 r->config_file = NULL;
11315                         }
11316                         ndr->flags = _flags_save_string;
11317                 }
11318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
11319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11321         }
11322         if (ndr_flags & NDR_BUFFERS) {
11323                 {
11324                         uint32_t _flags_save_string = ndr->flags;
11325                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11326                         if (r->driver_name) {
11327                                 uint32_t _relative_save_offset;
11328                                 _relative_save_offset = ndr->offset;
11329                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11330                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11331                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11332                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11333                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11334                                 ndr->offset = _relative_save_offset;
11335                         }
11336                         ndr->flags = _flags_save_string;
11337                 }
11338                 {
11339                         uint32_t _flags_save_string = ndr->flags;
11340                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11341                         if (r->architecture) {
11342                                 uint32_t _relative_save_offset;
11343                                 _relative_save_offset = ndr->offset;
11344                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11345                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11346                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11347                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11348                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11349                                 ndr->offset = _relative_save_offset;
11350                         }
11351                         ndr->flags = _flags_save_string;
11352                 }
11353                 {
11354                         uint32_t _flags_save_string = ndr->flags;
11355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11356                         if (r->driver_path) {
11357                                 uint32_t _relative_save_offset;
11358                                 _relative_save_offset = ndr->offset;
11359                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11360                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11361                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11362                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11363                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11364                                 ndr->offset = _relative_save_offset;
11365                         }
11366                         ndr->flags = _flags_save_string;
11367                 }
11368                 {
11369                         uint32_t _flags_save_string = ndr->flags;
11370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11371                         if (r->data_file) {
11372                                 uint32_t _relative_save_offset;
11373                                 _relative_save_offset = ndr->offset;
11374                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11375                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11376                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11377                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11378                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11379                                 ndr->offset = _relative_save_offset;
11380                         }
11381                         ndr->flags = _flags_save_string;
11382                 }
11383                 {
11384                         uint32_t _flags_save_string = ndr->flags;
11385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11386                         if (r->config_file) {
11387                                 uint32_t _relative_save_offset;
11388                                 _relative_save_offset = ndr->offset;
11389                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11390                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11391                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11392                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11393                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11394                                 ndr->offset = _relative_save_offset;
11395                         }
11396                         ndr->flags = _flags_save_string;
11397                 }
11398         }
11399         return NDR_ERR_SUCCESS;
11400 }
11401
11402 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11403 {
11404         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11405         ndr->depth++;
11406         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11407         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11408         ndr->depth++;
11409         if (r->driver_name) {
11410                 ndr_print_string(ndr, "driver_name", r->driver_name);
11411         }
11412         ndr->depth--;
11413         ndr_print_ptr(ndr, "architecture", r->architecture);
11414         ndr->depth++;
11415         if (r->architecture) {
11416                 ndr_print_string(ndr, "architecture", r->architecture);
11417         }
11418         ndr->depth--;
11419         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11420         ndr->depth++;
11421         if (r->driver_path) {
11422                 ndr_print_string(ndr, "driver_path", r->driver_path);
11423         }
11424         ndr->depth--;
11425         ndr_print_ptr(ndr, "data_file", r->data_file);
11426         ndr->depth++;
11427         if (r->data_file) {
11428                 ndr_print_string(ndr, "data_file", r->data_file);
11429         }
11430         ndr->depth--;
11431         ndr_print_ptr(ndr, "config_file", r->config_file);
11432         ndr->depth++;
11433         if (r->config_file) {
11434                 ndr_print_string(ndr, "config_file", r->config_file);
11435         }
11436         ndr->depth--;
11437         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
11438         ndr_print_uint32(ndr, "config_version", r->config_version);
11439         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11440         ndr->depth--;
11441 }
11442
11443 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11444 {
11445         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11446 }
11447
11448 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11449 {
11450         if (ndr_flags & NDR_SCALARS) {
11451                 NDR_CHECK(ndr_push_align(ndr, 8));
11452                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11453                 {
11454                         uint32_t _flags_save_string = ndr->flags;
11455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11456                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11457                         ndr->flags = _flags_save_string;
11458                 }
11459                 {
11460                         uint32_t _flags_save_string = ndr->flags;
11461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11462                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11463                         ndr->flags = _flags_save_string;
11464                 }
11465                 {
11466                         uint32_t _flags_save_string = ndr->flags;
11467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11468                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11469                         ndr->flags = _flags_save_string;
11470                 }
11471                 {
11472                         uint32_t _flags_save_string = ndr->flags;
11473                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11474                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11475                         ndr->flags = _flags_save_string;
11476                 }
11477                 {
11478                         uint32_t _flags_save_string = ndr->flags;
11479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11480                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11481                         ndr->flags = _flags_save_string;
11482                 }
11483                 {
11484                         uint32_t _flags_save_string = ndr->flags;
11485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11486                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11487                         ndr->flags = _flags_save_string;
11488                 }
11489                 {
11490                         uint32_t _flags_save_string_array = ndr->flags;
11491                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11492                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11493                         ndr->flags = _flags_save_string_array;
11494                 }
11495                 {
11496                         uint32_t _flags_save_string = ndr->flags;
11497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11499                         ndr->flags = _flags_save_string;
11500                 }
11501                 {
11502                         uint32_t _flags_save_string = ndr->flags;
11503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11505                         ndr->flags = _flags_save_string;
11506                 }
11507                 {
11508                         uint32_t _flags_save_string_array = ndr->flags;
11509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11510                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11511                         ndr->flags = _flags_save_string_array;
11512                 }
11513                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11514                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11515                 {
11516                         uint32_t _flags_save_string = ndr->flags;
11517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11518                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11519                         ndr->flags = _flags_save_string;
11520                 }
11521                 {
11522                         uint32_t _flags_save_string = ndr->flags;
11523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11524                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11525                         ndr->flags = _flags_save_string;
11526                 }
11527                 {
11528                         uint32_t _flags_save_string = ndr->flags;
11529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11530                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11531                         ndr->flags = _flags_save_string;
11532                 }
11533                 {
11534                         uint32_t _flags_save_string = ndr->flags;
11535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11536                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11537                         ndr->flags = _flags_save_string;
11538                 }
11539         }
11540         if (ndr_flags & NDR_BUFFERS) {
11541                 {
11542                         uint32_t _flags_save_string = ndr->flags;
11543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11544                         if (r->driver_name) {
11545                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11546                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11547                         }
11548                         ndr->flags = _flags_save_string;
11549                 }
11550                 {
11551                         uint32_t _flags_save_string = ndr->flags;
11552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11553                         if (r->architecture) {
11554                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11555                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11556                         }
11557                         ndr->flags = _flags_save_string;
11558                 }
11559                 {
11560                         uint32_t _flags_save_string = ndr->flags;
11561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11562                         if (r->driver_path) {
11563                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11564                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11565                         }
11566                         ndr->flags = _flags_save_string;
11567                 }
11568                 {
11569                         uint32_t _flags_save_string = ndr->flags;
11570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11571                         if (r->data_file) {
11572                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11573                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11574                         }
11575                         ndr->flags = _flags_save_string;
11576                 }
11577                 {
11578                         uint32_t _flags_save_string = ndr->flags;
11579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11580                         if (r->config_file) {
11581                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11582                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11583                         }
11584                         ndr->flags = _flags_save_string;
11585                 }
11586                 {
11587                         uint32_t _flags_save_string = ndr->flags;
11588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                         if (r->help_file) {
11590                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11591                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11592                         }
11593                         ndr->flags = _flags_save_string;
11594                 }
11595                 {
11596                         uint32_t _flags_save_string_array = ndr->flags;
11597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11598                         if (r->dependent_files) {
11599                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11600                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11601                         }
11602                         ndr->flags = _flags_save_string_array;
11603                 }
11604                 {
11605                         uint32_t _flags_save_string = ndr->flags;
11606                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11607                         if (r->monitor_name) {
11608                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11609                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11610                         }
11611                         ndr->flags = _flags_save_string;
11612                 }
11613                 {
11614                         uint32_t _flags_save_string = ndr->flags;
11615                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11616                         if (r->default_datatype) {
11617                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11618                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11619                         }
11620                         ndr->flags = _flags_save_string;
11621                 }
11622                 {
11623                         uint32_t _flags_save_string_array = ndr->flags;
11624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11625                         if (r->previous_names) {
11626                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11627                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11628                         }
11629                         ndr->flags = _flags_save_string_array;
11630                 }
11631                 {
11632                         uint32_t _flags_save_string = ndr->flags;
11633                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11634                         if (r->manufacturer_name) {
11635                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11636                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11637                         }
11638                         ndr->flags = _flags_save_string;
11639                 }
11640                 {
11641                         uint32_t _flags_save_string = ndr->flags;
11642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11643                         if (r->manufacturer_url) {
11644                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11645                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11646                         }
11647                         ndr->flags = _flags_save_string;
11648                 }
11649                 {
11650                         uint32_t _flags_save_string = ndr->flags;
11651                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11652                         if (r->hardware_id) {
11653                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11654                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11655                         }
11656                         ndr->flags = _flags_save_string;
11657                 }
11658                 {
11659                         uint32_t _flags_save_string = ndr->flags;
11660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11661                         if (r->provider) {
11662                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11663                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11664                         }
11665                         ndr->flags = _flags_save_string;
11666                 }
11667         }
11668         return NDR_ERR_SUCCESS;
11669 }
11670
11671 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11672 {
11673         uint32_t _ptr_driver_name;
11674         TALLOC_CTX *_mem_save_driver_name_0;
11675         uint32_t _ptr_architecture;
11676         TALLOC_CTX *_mem_save_architecture_0;
11677         uint32_t _ptr_driver_path;
11678         TALLOC_CTX *_mem_save_driver_path_0;
11679         uint32_t _ptr_data_file;
11680         TALLOC_CTX *_mem_save_data_file_0;
11681         uint32_t _ptr_config_file;
11682         TALLOC_CTX *_mem_save_config_file_0;
11683         uint32_t _ptr_help_file;
11684         TALLOC_CTX *_mem_save_help_file_0;
11685         uint32_t _ptr_dependent_files;
11686         TALLOC_CTX *_mem_save_dependent_files_0;
11687         uint32_t _ptr_monitor_name;
11688         TALLOC_CTX *_mem_save_monitor_name_0;
11689         uint32_t _ptr_default_datatype;
11690         TALLOC_CTX *_mem_save_default_datatype_0;
11691         uint32_t _ptr_previous_names;
11692         TALLOC_CTX *_mem_save_previous_names_0;
11693         uint32_t _ptr_manufacturer_name;
11694         TALLOC_CTX *_mem_save_manufacturer_name_0;
11695         uint32_t _ptr_manufacturer_url;
11696         TALLOC_CTX *_mem_save_manufacturer_url_0;
11697         uint32_t _ptr_hardware_id;
11698         TALLOC_CTX *_mem_save_hardware_id_0;
11699         uint32_t _ptr_provider;
11700         TALLOC_CTX *_mem_save_provider_0;
11701         if (ndr_flags & NDR_SCALARS) {
11702                 NDR_CHECK(ndr_pull_align(ndr, 8));
11703                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11704                 {
11705                         uint32_t _flags_save_string = ndr->flags;
11706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11707                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11708                         if (_ptr_driver_name) {
11709                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11710                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11711                         } else {
11712                                 r->driver_name = NULL;
11713                         }
11714                         ndr->flags = _flags_save_string;
11715                 }
11716                 {
11717                         uint32_t _flags_save_string = ndr->flags;
11718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11719                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11720                         if (_ptr_architecture) {
11721                                 NDR_PULL_ALLOC(ndr, r->architecture);
11722                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11723                         } else {
11724                                 r->architecture = NULL;
11725                         }
11726                         ndr->flags = _flags_save_string;
11727                 }
11728                 {
11729                         uint32_t _flags_save_string = ndr->flags;
11730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11731                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11732                         if (_ptr_driver_path) {
11733                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11734                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11735                         } else {
11736                                 r->driver_path = NULL;
11737                         }
11738                         ndr->flags = _flags_save_string;
11739                 }
11740                 {
11741                         uint32_t _flags_save_string = ndr->flags;
11742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11743                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11744                         if (_ptr_data_file) {
11745                                 NDR_PULL_ALLOC(ndr, r->data_file);
11746                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11747                         } else {
11748                                 r->data_file = NULL;
11749                         }
11750                         ndr->flags = _flags_save_string;
11751                 }
11752                 {
11753                         uint32_t _flags_save_string = ndr->flags;
11754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11756                         if (_ptr_config_file) {
11757                                 NDR_PULL_ALLOC(ndr, r->config_file);
11758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11759                         } else {
11760                                 r->config_file = NULL;
11761                         }
11762                         ndr->flags = _flags_save_string;
11763                 }
11764                 {
11765                         uint32_t _flags_save_string = ndr->flags;
11766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11767                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11768                         if (_ptr_help_file) {
11769                                 NDR_PULL_ALLOC(ndr, r->help_file);
11770                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11771                         } else {
11772                                 r->help_file = NULL;
11773                         }
11774                         ndr->flags = _flags_save_string;
11775                 }
11776                 {
11777                         uint32_t _flags_save_string_array = ndr->flags;
11778                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11779                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11780                         if (_ptr_dependent_files) {
11781                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11782                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11783                         } else {
11784                                 r->dependent_files = NULL;
11785                         }
11786                         ndr->flags = _flags_save_string_array;
11787                 }
11788                 {
11789                         uint32_t _flags_save_string = ndr->flags;
11790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11791                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11792                         if (_ptr_monitor_name) {
11793                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11794                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11795                         } else {
11796                                 r->monitor_name = NULL;
11797                         }
11798                         ndr->flags = _flags_save_string;
11799                 }
11800                 {
11801                         uint32_t _flags_save_string = ndr->flags;
11802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11803                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11804                         if (_ptr_default_datatype) {
11805                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11806                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11807                         } else {
11808                                 r->default_datatype = NULL;
11809                         }
11810                         ndr->flags = _flags_save_string;
11811                 }
11812                 {
11813                         uint32_t _flags_save_string_array = ndr->flags;
11814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11816                         if (_ptr_previous_names) {
11817                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11819                         } else {
11820                                 r->previous_names = NULL;
11821                         }
11822                         ndr->flags = _flags_save_string_array;
11823                 }
11824                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11825                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11826                 {
11827                         uint32_t _flags_save_string = ndr->flags;
11828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11829                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11830                         if (_ptr_manufacturer_name) {
11831                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11832                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11833                         } else {
11834                                 r->manufacturer_name = NULL;
11835                         }
11836                         ndr->flags = _flags_save_string;
11837                 }
11838                 {
11839                         uint32_t _flags_save_string = ndr->flags;
11840                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11841                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11842                         if (_ptr_manufacturer_url) {
11843                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11844                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11845                         } else {
11846                                 r->manufacturer_url = NULL;
11847                         }
11848                         ndr->flags = _flags_save_string;
11849                 }
11850                 {
11851                         uint32_t _flags_save_string = ndr->flags;
11852                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11853                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11854                         if (_ptr_hardware_id) {
11855                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11856                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11857                         } else {
11858                                 r->hardware_id = NULL;
11859                         }
11860                         ndr->flags = _flags_save_string;
11861                 }
11862                 {
11863                         uint32_t _flags_save_string = ndr->flags;
11864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11865                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11866                         if (_ptr_provider) {
11867                                 NDR_PULL_ALLOC(ndr, r->provider);
11868                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11869                         } else {
11870                                 r->provider = NULL;
11871                         }
11872                         ndr->flags = _flags_save_string;
11873                 }
11874         }
11875         if (ndr_flags & NDR_BUFFERS) {
11876                 {
11877                         uint32_t _flags_save_string = ndr->flags;
11878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11879                         if (r->driver_name) {
11880                                 uint32_t _relative_save_offset;
11881                                 _relative_save_offset = ndr->offset;
11882                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11883                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11884                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11885                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11886                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11887                                 ndr->offset = _relative_save_offset;
11888                         }
11889                         ndr->flags = _flags_save_string;
11890                 }
11891                 {
11892                         uint32_t _flags_save_string = ndr->flags;
11893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11894                         if (r->architecture) {
11895                                 uint32_t _relative_save_offset;
11896                                 _relative_save_offset = ndr->offset;
11897                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11898                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11899                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11900                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11901                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11902                                 ndr->offset = _relative_save_offset;
11903                         }
11904                         ndr->flags = _flags_save_string;
11905                 }
11906                 {
11907                         uint32_t _flags_save_string = ndr->flags;
11908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11909                         if (r->driver_path) {
11910                                 uint32_t _relative_save_offset;
11911                                 _relative_save_offset = ndr->offset;
11912                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11913                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11914                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11915                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11916                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11917                                 ndr->offset = _relative_save_offset;
11918                         }
11919                         ndr->flags = _flags_save_string;
11920                 }
11921                 {
11922                         uint32_t _flags_save_string = ndr->flags;
11923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11924                         if (r->data_file) {
11925                                 uint32_t _relative_save_offset;
11926                                 _relative_save_offset = ndr->offset;
11927                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11928                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11929                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11930                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11931                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11932                                 ndr->offset = _relative_save_offset;
11933                         }
11934                         ndr->flags = _flags_save_string;
11935                 }
11936                 {
11937                         uint32_t _flags_save_string = ndr->flags;
11938                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11939                         if (r->config_file) {
11940                                 uint32_t _relative_save_offset;
11941                                 _relative_save_offset = ndr->offset;
11942                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11943                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11944                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11945                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11946                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11947                                 ndr->offset = _relative_save_offset;
11948                         }
11949                         ndr->flags = _flags_save_string;
11950                 }
11951                 {
11952                         uint32_t _flags_save_string = ndr->flags;
11953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11954                         if (r->help_file) {
11955                                 uint32_t _relative_save_offset;
11956                                 _relative_save_offset = ndr->offset;
11957                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11958                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11959                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11960                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11961                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11962                                 ndr->offset = _relative_save_offset;
11963                         }
11964                         ndr->flags = _flags_save_string;
11965                 }
11966                 {
11967                         uint32_t _flags_save_string_array = ndr->flags;
11968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11969                         if (r->dependent_files) {
11970                                 uint32_t _relative_save_offset;
11971                                 _relative_save_offset = ndr->offset;
11972                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11973                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11974                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11975                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11976                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11977                                 ndr->offset = _relative_save_offset;
11978                         }
11979                         ndr->flags = _flags_save_string_array;
11980                 }
11981                 {
11982                         uint32_t _flags_save_string = ndr->flags;
11983                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11984                         if (r->monitor_name) {
11985                                 uint32_t _relative_save_offset;
11986                                 _relative_save_offset = ndr->offset;
11987                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11988                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11989                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11990                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11991                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11992                                 ndr->offset = _relative_save_offset;
11993                         }
11994                         ndr->flags = _flags_save_string;
11995                 }
11996                 {
11997                         uint32_t _flags_save_string = ndr->flags;
11998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11999                         if (r->default_datatype) {
12000                                 uint32_t _relative_save_offset;
12001                                 _relative_save_offset = ndr->offset;
12002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12003                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12004                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12007                                 ndr->offset = _relative_save_offset;
12008                         }
12009                         ndr->flags = _flags_save_string;
12010                 }
12011                 {
12012                         uint32_t _flags_save_string_array = ndr->flags;
12013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12014                         if (r->previous_names) {
12015                                 uint32_t _relative_save_offset;
12016                                 _relative_save_offset = ndr->offset;
12017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12018                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12019                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12020                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12022                                 ndr->offset = _relative_save_offset;
12023                         }
12024                         ndr->flags = _flags_save_string_array;
12025                 }
12026                 {
12027                         uint32_t _flags_save_string = ndr->flags;
12028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12029                         if (r->manufacturer_name) {
12030                                 uint32_t _relative_save_offset;
12031                                 _relative_save_offset = ndr->offset;
12032                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12033                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12034                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12035                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12037                                 ndr->offset = _relative_save_offset;
12038                         }
12039                         ndr->flags = _flags_save_string;
12040                 }
12041                 {
12042                         uint32_t _flags_save_string = ndr->flags;
12043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12044                         if (r->manufacturer_url) {
12045                                 uint32_t _relative_save_offset;
12046                                 _relative_save_offset = ndr->offset;
12047                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12048                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12049                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12050                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12051                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12052                                 ndr->offset = _relative_save_offset;
12053                         }
12054                         ndr->flags = _flags_save_string;
12055                 }
12056                 {
12057                         uint32_t _flags_save_string = ndr->flags;
12058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12059                         if (r->hardware_id) {
12060                                 uint32_t _relative_save_offset;
12061                                 _relative_save_offset = ndr->offset;
12062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12063                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12064                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12067                                 ndr->offset = _relative_save_offset;
12068                         }
12069                         ndr->flags = _flags_save_string;
12070                 }
12071                 {
12072                         uint32_t _flags_save_string = ndr->flags;
12073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12074                         if (r->provider) {
12075                                 uint32_t _relative_save_offset;
12076                                 _relative_save_offset = ndr->offset;
12077                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12078                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12079                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12080                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12081                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12082                                 ndr->offset = _relative_save_offset;
12083                         }
12084                         ndr->flags = _flags_save_string;
12085                 }
12086         }
12087         return NDR_ERR_SUCCESS;
12088 }
12089
12090 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12091 {
12092         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12093         ndr->depth++;
12094         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12095         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12096         ndr->depth++;
12097         if (r->driver_name) {
12098                 ndr_print_string(ndr, "driver_name", r->driver_name);
12099         }
12100         ndr->depth--;
12101         ndr_print_ptr(ndr, "architecture", r->architecture);
12102         ndr->depth++;
12103         if (r->architecture) {
12104                 ndr_print_string(ndr, "architecture", r->architecture);
12105         }
12106         ndr->depth--;
12107         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12108         ndr->depth++;
12109         if (r->driver_path) {
12110                 ndr_print_string(ndr, "driver_path", r->driver_path);
12111         }
12112         ndr->depth--;
12113         ndr_print_ptr(ndr, "data_file", r->data_file);
12114         ndr->depth++;
12115         if (r->data_file) {
12116                 ndr_print_string(ndr, "data_file", r->data_file);
12117         }
12118         ndr->depth--;
12119         ndr_print_ptr(ndr, "config_file", r->config_file);
12120         ndr->depth++;
12121         if (r->config_file) {
12122                 ndr_print_string(ndr, "config_file", r->config_file);
12123         }
12124         ndr->depth--;
12125         ndr_print_ptr(ndr, "help_file", r->help_file);
12126         ndr->depth++;
12127         if (r->help_file) {
12128                 ndr_print_string(ndr, "help_file", r->help_file);
12129         }
12130         ndr->depth--;
12131         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12132         ndr->depth++;
12133         if (r->dependent_files) {
12134                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12135         }
12136         ndr->depth--;
12137         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12138         ndr->depth++;
12139         if (r->monitor_name) {
12140                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12141         }
12142         ndr->depth--;
12143         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12144         ndr->depth++;
12145         if (r->default_datatype) {
12146                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12147         }
12148         ndr->depth--;
12149         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12150         ndr->depth++;
12151         if (r->previous_names) {
12152                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12153         }
12154         ndr->depth--;
12155         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12156         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12157         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12158         ndr->depth++;
12159         if (r->manufacturer_name) {
12160                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12161         }
12162         ndr->depth--;
12163         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12164         ndr->depth++;
12165         if (r->manufacturer_url) {
12166                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12167         }
12168         ndr->depth--;
12169         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12170         ndr->depth++;
12171         if (r->hardware_id) {
12172                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12173         }
12174         ndr->depth--;
12175         ndr_print_ptr(ndr, "provider", r->provider);
12176         ndr->depth++;
12177         if (r->provider) {
12178                 ndr_print_string(ndr, "provider", r->provider);
12179         }
12180         ndr->depth--;
12181         ndr->depth--;
12182 }
12183
12184 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12185 {
12186         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12187 }
12188
12189 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12190 {
12191         if (ndr_flags & NDR_SCALARS) {
12192                 NDR_CHECK(ndr_push_align(ndr, 8));
12193                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12194                 {
12195                         uint32_t _flags_save_string = ndr->flags;
12196                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12197                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12198                         ndr->flags = _flags_save_string;
12199                 }
12200                 {
12201                         uint32_t _flags_save_string = ndr->flags;
12202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12203                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12204                         ndr->flags = _flags_save_string;
12205                 }
12206                 {
12207                         uint32_t _flags_save_string = ndr->flags;
12208                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12209                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12210                         ndr->flags = _flags_save_string;
12211                 }
12212                 {
12213                         uint32_t _flags_save_string = ndr->flags;
12214                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12215                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12216                         ndr->flags = _flags_save_string;
12217                 }
12218                 {
12219                         uint32_t _flags_save_string = ndr->flags;
12220                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12221                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12222                         ndr->flags = _flags_save_string;
12223                 }
12224                 {
12225                         uint32_t _flags_save_string = ndr->flags;
12226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12227                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12228                         ndr->flags = _flags_save_string;
12229                 }
12230                 {
12231                         uint32_t _flags_save_string = ndr->flags;
12232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12233                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12234                         ndr->flags = _flags_save_string;
12235                 }
12236                 {
12237                         uint32_t _flags_save_string = ndr->flags;
12238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12239                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12240                         ndr->flags = _flags_save_string;
12241                 }
12242                 {
12243                         uint32_t _flags_save_string_array = ndr->flags;
12244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12245                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12246                         ndr->flags = _flags_save_string_array;
12247                 }
12248                 {
12249                         uint32_t _flags_save_string_array = ndr->flags;
12250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12251                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12252                         ndr->flags = _flags_save_string_array;
12253                 }
12254                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12255                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12256                 {
12257                         uint32_t _flags_save_string = ndr->flags;
12258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12260                         ndr->flags = _flags_save_string;
12261                 }
12262                 {
12263                         uint32_t _flags_save_string = ndr->flags;
12264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12266                         ndr->flags = _flags_save_string;
12267                 }
12268                 {
12269                         uint32_t _flags_save_string = ndr->flags;
12270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12271                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12272                         ndr->flags = _flags_save_string;
12273                 }
12274                 {
12275                         uint32_t _flags_save_string = ndr->flags;
12276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12277                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12278                         ndr->flags = _flags_save_string;
12279                 }
12280                 {
12281                         uint32_t _flags_save_string = ndr->flags;
12282                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12283                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12284                         ndr->flags = _flags_save_string;
12285                 }
12286                 {
12287                         uint32_t _flags_save_string = ndr->flags;
12288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12289                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12290                         ndr->flags = _flags_save_string;
12291                 }
12292                 {
12293                         uint32_t _flags_save_string_array = ndr->flags;
12294                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12295                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12296                         ndr->flags = _flags_save_string_array;
12297                 }
12298                 {
12299                         uint32_t _flags_save_string = ndr->flags;
12300                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12301                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12302                         ndr->flags = _flags_save_string;
12303                 }
12304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12305                 {
12306                         uint32_t _flags_save_string_array = ndr->flags;
12307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12308                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12309                         ndr->flags = _flags_save_string_array;
12310                 }
12311                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12312                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12313         }
12314         if (ndr_flags & NDR_BUFFERS) {
12315                 {
12316                         uint32_t _flags_save_string = ndr->flags;
12317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12318                         if (r->driver_name) {
12319                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12320                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12321                         }
12322                         ndr->flags = _flags_save_string;
12323                 }
12324                 {
12325                         uint32_t _flags_save_string = ndr->flags;
12326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12327                         if (r->architecture) {
12328                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12329                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12330                         }
12331                         ndr->flags = _flags_save_string;
12332                 }
12333                 {
12334                         uint32_t _flags_save_string = ndr->flags;
12335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12336                         if (r->driver_path) {
12337                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12338                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12339                         }
12340                         ndr->flags = _flags_save_string;
12341                 }
12342                 {
12343                         uint32_t _flags_save_string = ndr->flags;
12344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12345                         if (r->data_file) {
12346                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12347                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12348                         }
12349                         ndr->flags = _flags_save_string;
12350                 }
12351                 {
12352                         uint32_t _flags_save_string = ndr->flags;
12353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12354                         if (r->config_file) {
12355                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12356                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12357                         }
12358                         ndr->flags = _flags_save_string;
12359                 }
12360                 {
12361                         uint32_t _flags_save_string = ndr->flags;
12362                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12363                         if (r->help_file) {
12364                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12365                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12366                         }
12367                         ndr->flags = _flags_save_string;
12368                 }
12369                 {
12370                         uint32_t _flags_save_string = ndr->flags;
12371                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12372                         if (r->monitor_name) {
12373                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12374                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12375                         }
12376                         ndr->flags = _flags_save_string;
12377                 }
12378                 {
12379                         uint32_t _flags_save_string = ndr->flags;
12380                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12381                         if (r->default_datatype) {
12382                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12383                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12384                         }
12385                         ndr->flags = _flags_save_string;
12386                 }
12387                 {
12388                         uint32_t _flags_save_string_array = ndr->flags;
12389                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12390                         if (r->dependent_files) {
12391                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12392                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12393                         }
12394                         ndr->flags = _flags_save_string_array;
12395                 }
12396                 {
12397                         uint32_t _flags_save_string_array = ndr->flags;
12398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12399                         if (r->previous_names) {
12400                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12401                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12402                         }
12403                         ndr->flags = _flags_save_string_array;
12404                 }
12405                 {
12406                         uint32_t _flags_save_string = ndr->flags;
12407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12408                         if (r->manufacturer_name) {
12409                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12410                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12411                         }
12412                         ndr->flags = _flags_save_string;
12413                 }
12414                 {
12415                         uint32_t _flags_save_string = ndr->flags;
12416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12417                         if (r->manufacturer_url) {
12418                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12419                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12420                         }
12421                         ndr->flags = _flags_save_string;
12422                 }
12423                 {
12424                         uint32_t _flags_save_string = ndr->flags;
12425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12426                         if (r->hardware_id) {
12427                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12428                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12429                         }
12430                         ndr->flags = _flags_save_string;
12431                 }
12432                 {
12433                         uint32_t _flags_save_string = ndr->flags;
12434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12435                         if (r->provider) {
12436                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12437                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12438                         }
12439                         ndr->flags = _flags_save_string;
12440                 }
12441                 {
12442                         uint32_t _flags_save_string = ndr->flags;
12443                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12444                         if (r->print_processor) {
12445                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12446                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12447                         }
12448                         ndr->flags = _flags_save_string;
12449                 }
12450                 {
12451                         uint32_t _flags_save_string = ndr->flags;
12452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12453                         if (r->vendor_setup) {
12454                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12455                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12456                         }
12457                         ndr->flags = _flags_save_string;
12458                 }
12459                 {
12460                         uint32_t _flags_save_string_array = ndr->flags;
12461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12462                         if (r->color_profiles) {
12463                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12464                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12465                         }
12466                         ndr->flags = _flags_save_string_array;
12467                 }
12468                 {
12469                         uint32_t _flags_save_string = ndr->flags;
12470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12471                         if (r->inf_path) {
12472                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12473                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12474                         }
12475                         ndr->flags = _flags_save_string;
12476                 }
12477                 {
12478                         uint32_t _flags_save_string_array = ndr->flags;
12479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12480                         if (r->core_driver_dependencies) {
12481                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12482                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12483                         }
12484                         ndr->flags = _flags_save_string_array;
12485                 }
12486         }
12487         return NDR_ERR_SUCCESS;
12488 }
12489
12490 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12491 {
12492         uint32_t _ptr_driver_name;
12493         TALLOC_CTX *_mem_save_driver_name_0;
12494         uint32_t _ptr_architecture;
12495         TALLOC_CTX *_mem_save_architecture_0;
12496         uint32_t _ptr_driver_path;
12497         TALLOC_CTX *_mem_save_driver_path_0;
12498         uint32_t _ptr_data_file;
12499         TALLOC_CTX *_mem_save_data_file_0;
12500         uint32_t _ptr_config_file;
12501         TALLOC_CTX *_mem_save_config_file_0;
12502         uint32_t _ptr_help_file;
12503         TALLOC_CTX *_mem_save_help_file_0;
12504         uint32_t _ptr_monitor_name;
12505         TALLOC_CTX *_mem_save_monitor_name_0;
12506         uint32_t _ptr_default_datatype;
12507         TALLOC_CTX *_mem_save_default_datatype_0;
12508         uint32_t _ptr_dependent_files;
12509         TALLOC_CTX *_mem_save_dependent_files_0;
12510         uint32_t _ptr_previous_names;
12511         TALLOC_CTX *_mem_save_previous_names_0;
12512         uint32_t _ptr_manufacturer_name;
12513         TALLOC_CTX *_mem_save_manufacturer_name_0;
12514         uint32_t _ptr_manufacturer_url;
12515         TALLOC_CTX *_mem_save_manufacturer_url_0;
12516         uint32_t _ptr_hardware_id;
12517         TALLOC_CTX *_mem_save_hardware_id_0;
12518         uint32_t _ptr_provider;
12519         TALLOC_CTX *_mem_save_provider_0;
12520         uint32_t _ptr_print_processor;
12521         TALLOC_CTX *_mem_save_print_processor_0;
12522         uint32_t _ptr_vendor_setup;
12523         TALLOC_CTX *_mem_save_vendor_setup_0;
12524         uint32_t _ptr_color_profiles;
12525         TALLOC_CTX *_mem_save_color_profiles_0;
12526         uint32_t _ptr_inf_path;
12527         TALLOC_CTX *_mem_save_inf_path_0;
12528         uint32_t _ptr_core_driver_dependencies;
12529         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12530         if (ndr_flags & NDR_SCALARS) {
12531                 NDR_CHECK(ndr_pull_align(ndr, 8));
12532                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12533                 {
12534                         uint32_t _flags_save_string = ndr->flags;
12535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12536                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12537                         if (_ptr_driver_name) {
12538                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12539                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12540                         } else {
12541                                 r->driver_name = NULL;
12542                         }
12543                         ndr->flags = _flags_save_string;
12544                 }
12545                 {
12546                         uint32_t _flags_save_string = ndr->flags;
12547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12548                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12549                         if (_ptr_architecture) {
12550                                 NDR_PULL_ALLOC(ndr, r->architecture);
12551                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12552                         } else {
12553                                 r->architecture = NULL;
12554                         }
12555                         ndr->flags = _flags_save_string;
12556                 }
12557                 {
12558                         uint32_t _flags_save_string = ndr->flags;
12559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12560                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12561                         if (_ptr_driver_path) {
12562                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12563                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12564                         } else {
12565                                 r->driver_path = NULL;
12566                         }
12567                         ndr->flags = _flags_save_string;
12568                 }
12569                 {
12570                         uint32_t _flags_save_string = ndr->flags;
12571                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12572                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12573                         if (_ptr_data_file) {
12574                                 NDR_PULL_ALLOC(ndr, r->data_file);
12575                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12576                         } else {
12577                                 r->data_file = NULL;
12578                         }
12579                         ndr->flags = _flags_save_string;
12580                 }
12581                 {
12582                         uint32_t _flags_save_string = ndr->flags;
12583                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12584                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12585                         if (_ptr_config_file) {
12586                                 NDR_PULL_ALLOC(ndr, r->config_file);
12587                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12588                         } else {
12589                                 r->config_file = NULL;
12590                         }
12591                         ndr->flags = _flags_save_string;
12592                 }
12593                 {
12594                         uint32_t _flags_save_string = ndr->flags;
12595                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12596                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12597                         if (_ptr_help_file) {
12598                                 NDR_PULL_ALLOC(ndr, r->help_file);
12599                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12600                         } else {
12601                                 r->help_file = NULL;
12602                         }
12603                         ndr->flags = _flags_save_string;
12604                 }
12605                 {
12606                         uint32_t _flags_save_string = ndr->flags;
12607                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12608                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12609                         if (_ptr_monitor_name) {
12610                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12611                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12612                         } else {
12613                                 r->monitor_name = NULL;
12614                         }
12615                         ndr->flags = _flags_save_string;
12616                 }
12617                 {
12618                         uint32_t _flags_save_string = ndr->flags;
12619                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12620                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12621                         if (_ptr_default_datatype) {
12622                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12623                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12624                         } else {
12625                                 r->default_datatype = NULL;
12626                         }
12627                         ndr->flags = _flags_save_string;
12628                 }
12629                 {
12630                         uint32_t _flags_save_string_array = ndr->flags;
12631                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12632                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12633                         if (_ptr_dependent_files) {
12634                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12635                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12636                         } else {
12637                                 r->dependent_files = NULL;
12638                         }
12639                         ndr->flags = _flags_save_string_array;
12640                 }
12641                 {
12642                         uint32_t _flags_save_string_array = ndr->flags;
12643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12644                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12645                         if (_ptr_previous_names) {
12646                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12647                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12648                         } else {
12649                                 r->previous_names = NULL;
12650                         }
12651                         ndr->flags = _flags_save_string_array;
12652                 }
12653                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12654                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12655                 {
12656                         uint32_t _flags_save_string = ndr->flags;
12657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12658                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12659                         if (_ptr_manufacturer_name) {
12660                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12661                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12662                         } else {
12663                                 r->manufacturer_name = NULL;
12664                         }
12665                         ndr->flags = _flags_save_string;
12666                 }
12667                 {
12668                         uint32_t _flags_save_string = ndr->flags;
12669                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12670                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12671                         if (_ptr_manufacturer_url) {
12672                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12673                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12674                         } else {
12675                                 r->manufacturer_url = NULL;
12676                         }
12677                         ndr->flags = _flags_save_string;
12678                 }
12679                 {
12680                         uint32_t _flags_save_string = ndr->flags;
12681                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12682                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12683                         if (_ptr_hardware_id) {
12684                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12685                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12686                         } else {
12687                                 r->hardware_id = NULL;
12688                         }
12689                         ndr->flags = _flags_save_string;
12690                 }
12691                 {
12692                         uint32_t _flags_save_string = ndr->flags;
12693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12694                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12695                         if (_ptr_provider) {
12696                                 NDR_PULL_ALLOC(ndr, r->provider);
12697                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12698                         } else {
12699                                 r->provider = NULL;
12700                         }
12701                         ndr->flags = _flags_save_string;
12702                 }
12703                 {
12704                         uint32_t _flags_save_string = ndr->flags;
12705                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12706                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12707                         if (_ptr_print_processor) {
12708                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12709                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12710                         } else {
12711                                 r->print_processor = NULL;
12712                         }
12713                         ndr->flags = _flags_save_string;
12714                 }
12715                 {
12716                         uint32_t _flags_save_string = ndr->flags;
12717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12718                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12719                         if (_ptr_vendor_setup) {
12720                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12721                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12722                         } else {
12723                                 r->vendor_setup = NULL;
12724                         }
12725                         ndr->flags = _flags_save_string;
12726                 }
12727                 {
12728                         uint32_t _flags_save_string_array = ndr->flags;
12729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12730                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12731                         if (_ptr_color_profiles) {
12732                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12733                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12734                         } else {
12735                                 r->color_profiles = NULL;
12736                         }
12737                         ndr->flags = _flags_save_string_array;
12738                 }
12739                 {
12740                         uint32_t _flags_save_string = ndr->flags;
12741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12742                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12743                         if (_ptr_inf_path) {
12744                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12745                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12746                         } else {
12747                                 r->inf_path = NULL;
12748                         }
12749                         ndr->flags = _flags_save_string;
12750                 }
12751                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12752                 {
12753                         uint32_t _flags_save_string_array = ndr->flags;
12754                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12755                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12756                         if (_ptr_core_driver_dependencies) {
12757                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12758                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12759                         } else {
12760                                 r->core_driver_dependencies = NULL;
12761                         }
12762                         ndr->flags = _flags_save_string_array;
12763                 }
12764                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12765                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12766         }
12767         if (ndr_flags & NDR_BUFFERS) {
12768                 {
12769                         uint32_t _flags_save_string = ndr->flags;
12770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12771                         if (r->driver_name) {
12772                                 uint32_t _relative_save_offset;
12773                                 _relative_save_offset = ndr->offset;
12774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12775                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12776                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12779                                 ndr->offset = _relative_save_offset;
12780                         }
12781                         ndr->flags = _flags_save_string;
12782                 }
12783                 {
12784                         uint32_t _flags_save_string = ndr->flags;
12785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12786                         if (r->architecture) {
12787                                 uint32_t _relative_save_offset;
12788                                 _relative_save_offset = ndr->offset;
12789                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12790                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12791                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12792                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12793                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12794                                 ndr->offset = _relative_save_offset;
12795                         }
12796                         ndr->flags = _flags_save_string;
12797                 }
12798                 {
12799                         uint32_t _flags_save_string = ndr->flags;
12800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12801                         if (r->driver_path) {
12802                                 uint32_t _relative_save_offset;
12803                                 _relative_save_offset = ndr->offset;
12804                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12805                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12806                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12807                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12808                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12809                                 ndr->offset = _relative_save_offset;
12810                         }
12811                         ndr->flags = _flags_save_string;
12812                 }
12813                 {
12814                         uint32_t _flags_save_string = ndr->flags;
12815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12816                         if (r->data_file) {
12817                                 uint32_t _relative_save_offset;
12818                                 _relative_save_offset = ndr->offset;
12819                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12820                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12821                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12822                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12823                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12824                                 ndr->offset = _relative_save_offset;
12825                         }
12826                         ndr->flags = _flags_save_string;
12827                 }
12828                 {
12829                         uint32_t _flags_save_string = ndr->flags;
12830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12831                         if (r->config_file) {
12832                                 uint32_t _relative_save_offset;
12833                                 _relative_save_offset = ndr->offset;
12834                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12835                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12836                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12837                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12838                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12839                                 ndr->offset = _relative_save_offset;
12840                         }
12841                         ndr->flags = _flags_save_string;
12842                 }
12843                 {
12844                         uint32_t _flags_save_string = ndr->flags;
12845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12846                         if (r->help_file) {
12847                                 uint32_t _relative_save_offset;
12848                                 _relative_save_offset = ndr->offset;
12849                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12850                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12851                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12852                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12853                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12854                                 ndr->offset = _relative_save_offset;
12855                         }
12856                         ndr->flags = _flags_save_string;
12857                 }
12858                 {
12859                         uint32_t _flags_save_string = ndr->flags;
12860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12861                         if (r->monitor_name) {
12862                                 uint32_t _relative_save_offset;
12863                                 _relative_save_offset = ndr->offset;
12864                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12865                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12866                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12867                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12868                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12869                                 ndr->offset = _relative_save_offset;
12870                         }
12871                         ndr->flags = _flags_save_string;
12872                 }
12873                 {
12874                         uint32_t _flags_save_string = ndr->flags;
12875                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12876                         if (r->default_datatype) {
12877                                 uint32_t _relative_save_offset;
12878                                 _relative_save_offset = ndr->offset;
12879                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12880                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12881                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12882                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12883                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12884                                 ndr->offset = _relative_save_offset;
12885                         }
12886                         ndr->flags = _flags_save_string;
12887                 }
12888                 {
12889                         uint32_t _flags_save_string_array = ndr->flags;
12890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12891                         if (r->dependent_files) {
12892                                 uint32_t _relative_save_offset;
12893                                 _relative_save_offset = ndr->offset;
12894                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12895                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12896                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12897                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12898                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12899                                 ndr->offset = _relative_save_offset;
12900                         }
12901                         ndr->flags = _flags_save_string_array;
12902                 }
12903                 {
12904                         uint32_t _flags_save_string_array = ndr->flags;
12905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12906                         if (r->previous_names) {
12907                                 uint32_t _relative_save_offset;
12908                                 _relative_save_offset = ndr->offset;
12909                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12910                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12911                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12912                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12913                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12914                                 ndr->offset = _relative_save_offset;
12915                         }
12916                         ndr->flags = _flags_save_string_array;
12917                 }
12918                 {
12919                         uint32_t _flags_save_string = ndr->flags;
12920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12921                         if (r->manufacturer_name) {
12922                                 uint32_t _relative_save_offset;
12923                                 _relative_save_offset = ndr->offset;
12924                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12925                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12926                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12927                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12928                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12929                                 ndr->offset = _relative_save_offset;
12930                         }
12931                         ndr->flags = _flags_save_string;
12932                 }
12933                 {
12934                         uint32_t _flags_save_string = ndr->flags;
12935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12936                         if (r->manufacturer_url) {
12937                                 uint32_t _relative_save_offset;
12938                                 _relative_save_offset = ndr->offset;
12939                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12940                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12941                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12942                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12943                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12944                                 ndr->offset = _relative_save_offset;
12945                         }
12946                         ndr->flags = _flags_save_string;
12947                 }
12948                 {
12949                         uint32_t _flags_save_string = ndr->flags;
12950                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12951                         if (r->hardware_id) {
12952                                 uint32_t _relative_save_offset;
12953                                 _relative_save_offset = ndr->offset;
12954                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12955                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12956                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12957                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12958                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12959                                 ndr->offset = _relative_save_offset;
12960                         }
12961                         ndr->flags = _flags_save_string;
12962                 }
12963                 {
12964                         uint32_t _flags_save_string = ndr->flags;
12965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12966                         if (r->provider) {
12967                                 uint32_t _relative_save_offset;
12968                                 _relative_save_offset = ndr->offset;
12969                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12970                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12971                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12972                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12973                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12974                                 ndr->offset = _relative_save_offset;
12975                         }
12976                         ndr->flags = _flags_save_string;
12977                 }
12978                 {
12979                         uint32_t _flags_save_string = ndr->flags;
12980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12981                         if (r->print_processor) {
12982                                 uint32_t _relative_save_offset;
12983                                 _relative_save_offset = ndr->offset;
12984                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
12985                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
12986                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
12987                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
12988                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
12989                                 ndr->offset = _relative_save_offset;
12990                         }
12991                         ndr->flags = _flags_save_string;
12992                 }
12993                 {
12994                         uint32_t _flags_save_string = ndr->flags;
12995                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12996                         if (r->vendor_setup) {
12997                                 uint32_t _relative_save_offset;
12998                                 _relative_save_offset = ndr->offset;
12999                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13000                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13001                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13002                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13003                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13004                                 ndr->offset = _relative_save_offset;
13005                         }
13006                         ndr->flags = _flags_save_string;
13007                 }
13008                 {
13009                         uint32_t _flags_save_string_array = ndr->flags;
13010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13011                         if (r->color_profiles) {
13012                                 uint32_t _relative_save_offset;
13013                                 _relative_save_offset = ndr->offset;
13014                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13015                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13016                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13017                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13018                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13019                                 ndr->offset = _relative_save_offset;
13020                         }
13021                         ndr->flags = _flags_save_string_array;
13022                 }
13023                 {
13024                         uint32_t _flags_save_string = ndr->flags;
13025                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13026                         if (r->inf_path) {
13027                                 uint32_t _relative_save_offset;
13028                                 _relative_save_offset = ndr->offset;
13029                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13030                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13031                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13032                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13033                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13034                                 ndr->offset = _relative_save_offset;
13035                         }
13036                         ndr->flags = _flags_save_string;
13037                 }
13038                 {
13039                         uint32_t _flags_save_string_array = ndr->flags;
13040                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13041                         if (r->core_driver_dependencies) {
13042                                 uint32_t _relative_save_offset;
13043                                 _relative_save_offset = ndr->offset;
13044                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13045                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13046                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13047                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13048                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13049                                 ndr->offset = _relative_save_offset;
13050                         }
13051                         ndr->flags = _flags_save_string_array;
13052                 }
13053         }
13054         return NDR_ERR_SUCCESS;
13055 }
13056
13057 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13058 {
13059         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13060         ndr->depth++;
13061         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13062         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13063         ndr->depth++;
13064         if (r->driver_name) {
13065                 ndr_print_string(ndr, "driver_name", r->driver_name);
13066         }
13067         ndr->depth--;
13068         ndr_print_ptr(ndr, "architecture", r->architecture);
13069         ndr->depth++;
13070         if (r->architecture) {
13071                 ndr_print_string(ndr, "architecture", r->architecture);
13072         }
13073         ndr->depth--;
13074         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13075         ndr->depth++;
13076         if (r->driver_path) {
13077                 ndr_print_string(ndr, "driver_path", r->driver_path);
13078         }
13079         ndr->depth--;
13080         ndr_print_ptr(ndr, "data_file", r->data_file);
13081         ndr->depth++;
13082         if (r->data_file) {
13083                 ndr_print_string(ndr, "data_file", r->data_file);
13084         }
13085         ndr->depth--;
13086         ndr_print_ptr(ndr, "config_file", r->config_file);
13087         ndr->depth++;
13088         if (r->config_file) {
13089                 ndr_print_string(ndr, "config_file", r->config_file);
13090         }
13091         ndr->depth--;
13092         ndr_print_ptr(ndr, "help_file", r->help_file);
13093         ndr->depth++;
13094         if (r->help_file) {
13095                 ndr_print_string(ndr, "help_file", r->help_file);
13096         }
13097         ndr->depth--;
13098         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13099         ndr->depth++;
13100         if (r->monitor_name) {
13101                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13102         }
13103         ndr->depth--;
13104         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13105         ndr->depth++;
13106         if (r->default_datatype) {
13107                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13108         }
13109         ndr->depth--;
13110         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13111         ndr->depth++;
13112         if (r->dependent_files) {
13113                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13114         }
13115         ndr->depth--;
13116         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13117         ndr->depth++;
13118         if (r->previous_names) {
13119                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13120         }
13121         ndr->depth--;
13122         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13123         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13124         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13125         ndr->depth++;
13126         if (r->manufacturer_name) {
13127                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13128         }
13129         ndr->depth--;
13130         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13131         ndr->depth++;
13132         if (r->manufacturer_url) {
13133                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13134         }
13135         ndr->depth--;
13136         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13137         ndr->depth++;
13138         if (r->hardware_id) {
13139                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13140         }
13141         ndr->depth--;
13142         ndr_print_ptr(ndr, "provider", r->provider);
13143         ndr->depth++;
13144         if (r->provider) {
13145                 ndr_print_string(ndr, "provider", r->provider);
13146         }
13147         ndr->depth--;
13148         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13149         ndr->depth++;
13150         if (r->print_processor) {
13151                 ndr_print_string(ndr, "print_processor", r->print_processor);
13152         }
13153         ndr->depth--;
13154         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13155         ndr->depth++;
13156         if (r->vendor_setup) {
13157                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13158         }
13159         ndr->depth--;
13160         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13161         ndr->depth++;
13162         if (r->color_profiles) {
13163                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13164         }
13165         ndr->depth--;
13166         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13167         ndr->depth++;
13168         if (r->inf_path) {
13169                 ndr_print_string(ndr, "inf_path", r->inf_path);
13170         }
13171         ndr->depth--;
13172         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13173         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13174         ndr->depth++;
13175         if (r->core_driver_dependencies) {
13176                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13177         }
13178         ndr->depth--;
13179         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13180         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13181         ndr->depth--;
13182 }
13183
13184 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13185 {
13186         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13187 }
13188
13189 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13190 {
13191         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13192         return NDR_ERR_SUCCESS;
13193 }
13194
13195 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13196 {
13197         uint32_t v;
13198         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13199         *r = v;
13200         return NDR_ERR_SUCCESS;
13201 }
13202
13203 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13204 {
13205         const char *val = NULL;
13206
13207         switch (r) {
13208                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13209                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13210                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13211                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13212                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13213         }
13214         ndr_print_enum(ndr, name, "ENUM", val, r);
13215 }
13216
13217 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13218 {
13219         if (ndr_flags & NDR_SCALARS) {
13220                 NDR_CHECK(ndr_push_align(ndr, 4));
13221                 {
13222                         uint32_t _flags_save_string = ndr->flags;
13223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13224                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13225                         ndr->flags = _flags_save_string;
13226                 }
13227                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13228                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13229         }
13230         if (ndr_flags & NDR_BUFFERS) {
13231                 {
13232                         uint32_t _flags_save_string = ndr->flags;
13233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13234                         if (r->file_name) {
13235                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13236                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13237                         }
13238                         ndr->flags = _flags_save_string;
13239                 }
13240         }
13241         return NDR_ERR_SUCCESS;
13242 }
13243
13244 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13245 {
13246         uint32_t _ptr_file_name;
13247         TALLOC_CTX *_mem_save_file_name_0;
13248         if (ndr_flags & NDR_SCALARS) {
13249                 NDR_CHECK(ndr_pull_align(ndr, 4));
13250                 {
13251                         uint32_t _flags_save_string = ndr->flags;
13252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13253                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13254                         if (_ptr_file_name) {
13255                                 NDR_PULL_ALLOC(ndr, r->file_name);
13256                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13257                         } else {
13258                                 r->file_name = NULL;
13259                         }
13260                         ndr->flags = _flags_save_string;
13261                 }
13262                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13264         }
13265         if (ndr_flags & NDR_BUFFERS) {
13266                 {
13267                         uint32_t _flags_save_string = ndr->flags;
13268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13269                         if (r->file_name) {
13270                                 uint32_t _relative_save_offset;
13271                                 _relative_save_offset = ndr->offset;
13272                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13273                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13274                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13275                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13276                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13277                                 ndr->offset = _relative_save_offset;
13278                         }
13279                         ndr->flags = _flags_save_string;
13280                 }
13281         }
13282         return NDR_ERR_SUCCESS;
13283 }
13284
13285 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13286 {
13287         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13288         ndr->depth++;
13289         ndr_print_ptr(ndr, "file_name", r->file_name);
13290         ndr->depth++;
13291         if (r->file_name) {
13292                 ndr_print_string(ndr, "file_name", r->file_name);
13293         }
13294         ndr->depth--;
13295         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13296         ndr_print_uint32(ndr, "file_version", r->file_version);
13297         ndr->depth--;
13298 }
13299
13300 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13301 {
13302         uint32_t cntr_file_info_1;
13303         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13304         ndr->depth++;
13305         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13306         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13307         ndr->depth++;
13308         if (r->driver_name) {
13309                 ndr_print_string(ndr, "driver_name", r->driver_name);
13310         }
13311         ndr->depth--;
13312         ndr_print_ptr(ndr, "architecture", r->architecture);
13313         ndr->depth++;
13314         if (r->architecture) {
13315                 ndr_print_string(ndr, "architecture", r->architecture);
13316         }
13317         ndr->depth--;
13318         ndr_print_ptr(ndr, "file_info", r->file_info);
13319         ndr->depth++;
13320         if (r->file_info) {
13321                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13322                 ndr->depth++;
13323                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13324                         char *idx_1=NULL;
13325                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13326                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13327                                 free(idx_1);
13328                         }
13329                 }
13330                 ndr->depth--;
13331         }
13332         ndr->depth--;
13333         ndr_print_uint32(ndr, "file_count", r->file_count);
13334         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13335         ndr->depth++;
13336         if (r->monitor_name) {
13337                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13338         }
13339         ndr->depth--;
13340         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13341         ndr->depth++;
13342         if (r->default_datatype) {
13343                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13344         }
13345         ndr->depth--;
13346         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13347         ndr->depth++;
13348         if (r->previous_names) {
13349                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13350         }
13351         ndr->depth--;
13352         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13353         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13354         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13355         ndr->depth++;
13356         if (r->manufacturer_name) {
13357                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13358         }
13359         ndr->depth--;
13360         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13361         ndr->depth++;
13362         if (r->manufacturer_url) {
13363                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13364         }
13365         ndr->depth--;
13366         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13367         ndr->depth++;
13368         if (r->hardware_id) {
13369                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13370         }
13371         ndr->depth--;
13372         ndr_print_ptr(ndr, "provider", r->provider);
13373         ndr->depth++;
13374         if (r->provider) {
13375                 ndr_print_string(ndr, "provider", r->provider);
13376         }
13377         ndr->depth--;
13378         ndr->depth--;
13379 }
13380
13381 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13382 {
13383         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13384 }
13385
13386 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13387 {
13388         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13389         if (ndr_flags & NDR_SCALARS) {
13390                 int level = ndr_push_get_switch_value(ndr, r);
13391                 switch (level) {
13392                         case 1: {
13393                                 NDR_CHECK(ndr_push_align(ndr, 4));
13394                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13395                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13396                         break; }
13397
13398                         case 2: {
13399                                 NDR_CHECK(ndr_push_align(ndr, 4));
13400                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13401                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13402                         break; }
13403
13404                         case 3: {
13405                                 NDR_CHECK(ndr_push_align(ndr, 4));
13406                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13407                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13408                         break; }
13409
13410                         case 4: {
13411                                 NDR_CHECK(ndr_push_align(ndr, 4));
13412                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13413                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13414                         break; }
13415
13416                         case 5: {
13417                                 NDR_CHECK(ndr_push_align(ndr, 4));
13418                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13419                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13420                         break; }
13421
13422                         case 6: {
13423                                 NDR_CHECK(ndr_push_align(ndr, 8));
13424                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13425                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13426                         break; }
13427
13428                         case 8: {
13429                                 NDR_CHECK(ndr_push_align(ndr, 8));
13430                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13431                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13432                         break; }
13433
13434                         case 101: {
13435                                 NDR_CHECK(ndr_push_align(ndr, 8));
13436                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13437                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13438                         break; }
13439
13440                         default: {
13441                         break; }
13442
13443                 }
13444         }
13445         if (ndr_flags & NDR_BUFFERS) {
13446                 int level = ndr_push_get_switch_value(ndr, r);
13447                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13448                 switch (level) {
13449                         case 1:
13450                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13451                         break;
13452
13453                         case 2:
13454                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13455                         break;
13456
13457                         case 3:
13458                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13459                         break;
13460
13461                         case 4:
13462                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13463                         break;
13464
13465                         case 5:
13466                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13467                         break;
13468
13469                         case 6:
13470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13471                         break;
13472
13473                         case 8:
13474                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13475                         break;
13476
13477                         case 101:
13478                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13479                         break;
13480
13481                         default:
13482                         break;
13483
13484                 }
13485         }
13486         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13487         return NDR_ERR_SUCCESS;
13488 }
13489
13490 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13491 {
13492         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13493         int level;
13494         level = ndr_pull_get_switch_value(ndr, r);
13495         if (ndr_flags & NDR_SCALARS) {
13496                 switch (level) {
13497                         case 1: {
13498                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13499                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13500                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13501                         break; }
13502
13503                         case 2: {
13504                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13505                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13506                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13507                         break; }
13508
13509                         case 3: {
13510                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13511                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13512                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13513                         break; }
13514
13515                         case 4: {
13516                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13517                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13518                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13519                         break; }
13520
13521                         case 5: {
13522                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13523                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13524                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13525                         break; }
13526
13527                         case 6: {
13528                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13529                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13530                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13531                         break; }
13532
13533                         case 8: {
13534                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13535                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13536                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13537                         break; }
13538
13539                         case 101: {
13540                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13541                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13542                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13543                         break; }
13544
13545                         default: {
13546                         break; }
13547
13548                 }
13549         }
13550         if (ndr_flags & NDR_BUFFERS) {
13551                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13552                 switch (level) {
13553                         case 1:
13554                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13555                         break;
13556
13557                         case 2:
13558                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13559                         break;
13560
13561                         case 3:
13562                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13563                         break;
13564
13565                         case 4:
13566                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13567                         break;
13568
13569                         case 5:
13570                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13571                         break;
13572
13573                         case 6:
13574                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13575                         break;
13576
13577                         case 8:
13578                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13579                         break;
13580
13581                         case 101:
13582                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13583                         break;
13584
13585                         default:
13586                         break;
13587
13588                 }
13589         }
13590         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13591         return NDR_ERR_SUCCESS;
13592 }
13593
13594 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13595 {
13596         int level;
13597         level = ndr_print_get_switch_value(ndr, r);
13598         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13599         switch (level) {
13600                 case 1:
13601                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13602                 break;
13603
13604                 case 2:
13605                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13606                 break;
13607
13608                 case 3:
13609                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13610                 break;
13611
13612                 case 4:
13613                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13614                 break;
13615
13616                 case 5:
13617                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13618                 break;
13619
13620                 case 6:
13621                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13622                 break;
13623
13624                 case 8:
13625                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13626                 break;
13627
13628                 case 101:
13629                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13630                 break;
13631
13632                 default:
13633                 break;
13634
13635         }
13636 }
13637
13638 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13639 {
13640         if (ndr_flags & NDR_SCALARS) {
13641                 NDR_CHECK(ndr_push_align(ndr, 4));
13642                 {
13643                         uint32_t _flags_save_string = ndr->flags;
13644                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13645                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13646                         ndr->flags = _flags_save_string;
13647                 }
13648         }
13649         if (ndr_flags & NDR_BUFFERS) {
13650         }
13651         return NDR_ERR_SUCCESS;
13652 }
13653
13654 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13655 {
13656         if (ndr_flags & NDR_SCALARS) {
13657                 NDR_CHECK(ndr_pull_align(ndr, 4));
13658                 {
13659                         uint32_t _flags_save_string = ndr->flags;
13660                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13661                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13662                         ndr->flags = _flags_save_string;
13663                 }
13664         }
13665         if (ndr_flags & NDR_BUFFERS) {
13666         }
13667         return NDR_ERR_SUCCESS;
13668 }
13669
13670 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13671 {
13672         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13673         ndr->depth++;
13674         ndr_print_string(ndr, "directory_name", r->directory_name);
13675         ndr->depth--;
13676 }
13677
13678 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13679 {
13680         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13681 }
13682
13683 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13684 {
13685         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13686         if (ndr_flags & NDR_SCALARS) {
13687                 int level = ndr_push_get_switch_value(ndr, r);
13688                 switch (level) {
13689                         case 1: {
13690                                 NDR_CHECK(ndr_push_align(ndr, 4));
13691                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13692                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13693                         break; }
13694
13695                         default: {
13696                                 NDR_CHECK(ndr_push_align(ndr, 4));
13697                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13698                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13699                         break; }
13700
13701                 }
13702         }
13703         if (ndr_flags & NDR_BUFFERS) {
13704                 int level = ndr_push_get_switch_value(ndr, r);
13705                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13706                 switch (level) {
13707                         case 1:
13708                         break;
13709
13710                         default:
13711                         break;
13712
13713                 }
13714         }
13715         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13716         return NDR_ERR_SUCCESS;
13717 }
13718
13719 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13720 {
13721         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13722         int level;
13723         level = ndr_pull_get_switch_value(ndr, r);
13724         if (ndr_flags & NDR_SCALARS) {
13725                 switch (level) {
13726                         case 1: {
13727                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13728                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13729                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13730                         break; }
13731
13732                         default: {
13733                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13734                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13735                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13736                         break; }
13737
13738                 }
13739         }
13740         if (ndr_flags & NDR_BUFFERS) {
13741                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13742                 switch (level) {
13743                         case 1:
13744                         break;
13745
13746                         default:
13747                         break;
13748
13749                 }
13750         }
13751         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13752         return NDR_ERR_SUCCESS;
13753 }
13754
13755 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13756 {
13757         int level;
13758         level = ndr_print_get_switch_value(ndr, r);
13759         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13760         switch (level) {
13761                 case 1:
13762                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13763                 break;
13764
13765                 default:
13766                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13767                 break;
13768
13769         }
13770 }
13771
13772 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13773 {
13774         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13775 }
13776
13777 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13778 {
13779         if (ndr_flags & NDR_SCALARS) {
13780                 NDR_CHECK(ndr_push_align(ndr, 4));
13781                 {
13782                         uint32_t _flags_save_string = ndr->flags;
13783                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13784                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13785                         ndr->flags = _flags_save_string;
13786                 }
13787         }
13788         if (ndr_flags & NDR_BUFFERS) {
13789                 {
13790                         uint32_t _flags_save_string = ndr->flags;
13791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13792                         if (r->print_processor_name) {
13793                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13794                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13795                         }
13796                         ndr->flags = _flags_save_string;
13797                 }
13798         }
13799         return NDR_ERR_SUCCESS;
13800 }
13801
13802 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13803 {
13804         uint32_t _ptr_print_processor_name;
13805         TALLOC_CTX *_mem_save_print_processor_name_0;
13806         if (ndr_flags & NDR_SCALARS) {
13807                 NDR_CHECK(ndr_pull_align(ndr, 4));
13808                 {
13809                         uint32_t _flags_save_string = ndr->flags;
13810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13812                         if (_ptr_print_processor_name) {
13813                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13815                         } else {
13816                                 r->print_processor_name = NULL;
13817                         }
13818                         ndr->flags = _flags_save_string;
13819                 }
13820         }
13821         if (ndr_flags & NDR_BUFFERS) {
13822                 {
13823                         uint32_t _flags_save_string = ndr->flags;
13824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13825                         if (r->print_processor_name) {
13826                                 uint32_t _relative_save_offset;
13827                                 _relative_save_offset = ndr->offset;
13828                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13829                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13830                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13831                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13832                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13833                                 ndr->offset = _relative_save_offset;
13834                         }
13835                         ndr->flags = _flags_save_string;
13836                 }
13837         }
13838         return NDR_ERR_SUCCESS;
13839 }
13840
13841 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13842 {
13843         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13844         ndr->depth++;
13845         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13846         ndr->depth++;
13847         if (r->print_processor_name) {
13848                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13849         }
13850         ndr->depth--;
13851         ndr->depth--;
13852 }
13853
13854 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13855 {
13856         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13857 }
13858
13859 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13860 {
13861         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13862         if (ndr_flags & NDR_SCALARS) {
13863                 int level = ndr_push_get_switch_value(ndr, r);
13864                 switch (level) {
13865                         case 1: {
13866                                 NDR_CHECK(ndr_push_align(ndr, 4));
13867                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13868                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13869                         break; }
13870
13871                         default: {
13872                         break; }
13873
13874                 }
13875         }
13876         if (ndr_flags & NDR_BUFFERS) {
13877                 int level = ndr_push_get_switch_value(ndr, r);
13878                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13879                 switch (level) {
13880                         case 1:
13881                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13882                         break;
13883
13884                         default:
13885                         break;
13886
13887                 }
13888         }
13889         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13890         return NDR_ERR_SUCCESS;
13891 }
13892
13893 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13894 {
13895         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13896         int level;
13897         level = ndr_pull_get_switch_value(ndr, r);
13898         if (ndr_flags & NDR_SCALARS) {
13899                 switch (level) {
13900                         case 1: {
13901                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13902                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13903                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13904                         break; }
13905
13906                         default: {
13907                         break; }
13908
13909                 }
13910         }
13911         if (ndr_flags & NDR_BUFFERS) {
13912                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13913                 switch (level) {
13914                         case 1:
13915                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13916                         break;
13917
13918                         default:
13919                         break;
13920
13921                 }
13922         }
13923         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13924         return NDR_ERR_SUCCESS;
13925 }
13926
13927 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
13928 {
13929         int level;
13930         level = ndr_print_get_switch_value(ndr, r);
13931         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
13932         switch (level) {
13933                 case 1:
13934                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
13935                 break;
13936
13937                 default:
13938                 break;
13939
13940         }
13941 }
13942
13943 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13944 {
13945         if (ndr_flags & NDR_SCALARS) {
13946                 NDR_CHECK(ndr_push_align(ndr, 4));
13947                 {
13948                         uint32_t _flags_save_string = ndr->flags;
13949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13950                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13951                         ndr->flags = _flags_save_string;
13952                 }
13953         }
13954         if (ndr_flags & NDR_BUFFERS) {
13955         }
13956         return NDR_ERR_SUCCESS;
13957 }
13958
13959 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
13960 {
13961         if (ndr_flags & NDR_SCALARS) {
13962                 NDR_CHECK(ndr_pull_align(ndr, 4));
13963                 {
13964                         uint32_t _flags_save_string = ndr->flags;
13965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13966                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13967                         ndr->flags = _flags_save_string;
13968                 }
13969         }
13970         if (ndr_flags & NDR_BUFFERS) {
13971         }
13972         return NDR_ERR_SUCCESS;
13973 }
13974
13975 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
13976 {
13977         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
13978         ndr->depth++;
13979         ndr_print_string(ndr, "directory_name", r->directory_name);
13980         ndr->depth--;
13981 }
13982
13983 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13984 {
13985         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
13986 }
13987
13988 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
13989 {
13990         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13991         if (ndr_flags & NDR_SCALARS) {
13992                 int level = ndr_push_get_switch_value(ndr, r);
13993                 switch (level) {
13994                         case 1: {
13995                                 NDR_CHECK(ndr_push_align(ndr, 4));
13996                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13997                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13998                         break; }
13999
14000                         default: {
14001                                 NDR_CHECK(ndr_push_align(ndr, 4));
14002                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14003                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14004                         break; }
14005
14006                 }
14007         }
14008         if (ndr_flags & NDR_BUFFERS) {
14009                 int level = ndr_push_get_switch_value(ndr, r);
14010                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14011                 switch (level) {
14012                         case 1:
14013                         break;
14014
14015                         default:
14016                         break;
14017
14018                 }
14019         }
14020         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14021         return NDR_ERR_SUCCESS;
14022 }
14023
14024 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14025 {
14026         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14027         int level;
14028         level = ndr_pull_get_switch_value(ndr, r);
14029         if (ndr_flags & NDR_SCALARS) {
14030                 switch (level) {
14031                         case 1: {
14032                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14033                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14034                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14035                         break; }
14036
14037                         default: {
14038                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14039                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14040                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14041                         break; }
14042
14043                 }
14044         }
14045         if (ndr_flags & NDR_BUFFERS) {
14046                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14047                 switch (level) {
14048                         case 1:
14049                         break;
14050
14051                         default:
14052                         break;
14053
14054                 }
14055         }
14056         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14057         return NDR_ERR_SUCCESS;
14058 }
14059
14060 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14061 {
14062         int level;
14063         level = ndr_print_get_switch_value(ndr, r);
14064         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14065         switch (level) {
14066                 case 1:
14067                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14068                 break;
14069
14070                 default:
14071                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14072                 break;
14073
14074         }
14075 }
14076
14077 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14078 {
14079         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14080 }
14081
14082 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14083 {
14084         if (ndr_flags & NDR_SCALARS) {
14085                 NDR_CHECK(ndr_push_align(ndr, 4));
14086                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14087                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14088                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14089         }
14090         if (ndr_flags & NDR_BUFFERS) {
14091                 if (r->document_name) {
14092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14096                 }
14097                 if (r->output_file) {
14098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14101                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14102                 }
14103                 if (r->datatype) {
14104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14107                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14108                 }
14109         }
14110         return NDR_ERR_SUCCESS;
14111 }
14112
14113 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14114 {
14115         uint32_t _ptr_document_name;
14116         TALLOC_CTX *_mem_save_document_name_0;
14117         uint32_t _ptr_output_file;
14118         TALLOC_CTX *_mem_save_output_file_0;
14119         uint32_t _ptr_datatype;
14120         TALLOC_CTX *_mem_save_datatype_0;
14121         if (ndr_flags & NDR_SCALARS) {
14122                 NDR_CHECK(ndr_pull_align(ndr, 4));
14123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14124                 if (_ptr_document_name) {
14125                         NDR_PULL_ALLOC(ndr, r->document_name);
14126                 } else {
14127                         r->document_name = NULL;
14128                 }
14129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14130                 if (_ptr_output_file) {
14131                         NDR_PULL_ALLOC(ndr, r->output_file);
14132                 } else {
14133                         r->output_file = NULL;
14134                 }
14135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14136                 if (_ptr_datatype) {
14137                         NDR_PULL_ALLOC(ndr, r->datatype);
14138                 } else {
14139                         r->datatype = NULL;
14140                 }
14141         }
14142         if (ndr_flags & NDR_BUFFERS) {
14143                 if (r->document_name) {
14144                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14145                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14146                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14147                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14148                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14149                                 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));
14150                         }
14151                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14152                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14153                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14154                 }
14155                 if (r->output_file) {
14156                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14157                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14159                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14160                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14161                                 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));
14162                         }
14163                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14164                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14166                 }
14167                 if (r->datatype) {
14168                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14169                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14170                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14171                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14172                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14173                                 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));
14174                         }
14175                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14176                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14177                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14178                 }
14179         }
14180         return NDR_ERR_SUCCESS;
14181 }
14182
14183 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14184 {
14185         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14186         ndr->depth++;
14187         ndr_print_ptr(ndr, "document_name", r->document_name);
14188         ndr->depth++;
14189         if (r->document_name) {
14190                 ndr_print_string(ndr, "document_name", r->document_name);
14191         }
14192         ndr->depth--;
14193         ndr_print_ptr(ndr, "output_file", r->output_file);
14194         ndr->depth++;
14195         if (r->output_file) {
14196                 ndr_print_string(ndr, "output_file", r->output_file);
14197         }
14198         ndr->depth--;
14199         ndr_print_ptr(ndr, "datatype", r->datatype);
14200         ndr->depth++;
14201         if (r->datatype) {
14202                 ndr_print_string(ndr, "datatype", r->datatype);
14203         }
14204         ndr->depth--;
14205         ndr->depth--;
14206 }
14207
14208 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14209 {
14210         if (ndr_flags & NDR_SCALARS) {
14211                 int level = ndr_push_get_switch_value(ndr, r);
14212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14213                 switch (level) {
14214                         case 1: {
14215                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14216                         break; }
14217
14218                         case 2: {
14219                         break; }
14220
14221                         case 3: {
14222                         break; }
14223
14224                         default: {
14225                         break; }
14226
14227                 }
14228         }
14229         if (ndr_flags & NDR_BUFFERS) {
14230                 int level = ndr_push_get_switch_value(ndr, r);
14231                 switch (level) {
14232                         case 1:
14233                                 if (r->info1) {
14234                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14235                                 }
14236                         break;
14237
14238                         case 2:
14239                         break;
14240
14241                         case 3:
14242                         break;
14243
14244                         default:
14245                         break;
14246
14247                 }
14248         }
14249         return NDR_ERR_SUCCESS;
14250 }
14251
14252 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14253 {
14254         int level;
14255         uint32_t _level;
14256         TALLOC_CTX *_mem_save_info1_0;
14257         level = ndr_pull_get_switch_value(ndr, r);
14258         if (ndr_flags & NDR_SCALARS) {
14259                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14260                 if (_level != level) {
14261                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14262                 }
14263                 switch (level) {
14264                         case 1: {
14265                                 uint32_t _ptr_info1;
14266                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14267                                 if (_ptr_info1) {
14268                                         NDR_PULL_ALLOC(ndr, r->info1);
14269                                 } else {
14270                                         r->info1 = NULL;
14271                                 }
14272                         break; }
14273
14274                         case 2: {
14275                         break; }
14276
14277                         case 3: {
14278                         break; }
14279
14280                         default: {
14281                         break; }
14282
14283                 }
14284         }
14285         if (ndr_flags & NDR_BUFFERS) {
14286                 switch (level) {
14287                         case 1:
14288                                 if (r->info1) {
14289                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14290                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14291                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14292                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14293                                 }
14294                         break;
14295
14296                         case 2:
14297                         break;
14298
14299                         case 3:
14300                         break;
14301
14302                         default:
14303                         break;
14304
14305                 }
14306         }
14307         return NDR_ERR_SUCCESS;
14308 }
14309
14310 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14311 {
14312         int level;
14313         level = ndr_print_get_switch_value(ndr, r);
14314         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14315         switch (level) {
14316                 case 1:
14317                         ndr_print_ptr(ndr, "info1", r->info1);
14318                         ndr->depth++;
14319                         if (r->info1) {
14320                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14321                         }
14322                         ndr->depth--;
14323                 break;
14324
14325                 case 2:
14326                 break;
14327
14328                 case 3:
14329                 break;
14330
14331                 default:
14332                 break;
14333
14334         }
14335 }
14336
14337 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14338 {
14339         if (ndr_flags & NDR_SCALARS) {
14340                 NDR_CHECK(ndr_push_align(ndr, 4));
14341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14346                 {
14347                         uint32_t _flags_save_string = ndr->flags;
14348                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14349                         {
14350                                 struct ndr_push *_ndr_extra_string;
14351                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14352                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14353                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14354                         }
14355                         ndr->flags = _flags_save_string;
14356                 }
14357         }
14358         if (ndr_flags & NDR_BUFFERS) {
14359         }
14360         return NDR_ERR_SUCCESS;
14361 }
14362
14363 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14364 {
14365         if (ndr_flags & NDR_SCALARS) {
14366                 NDR_CHECK(ndr_pull_align(ndr, 4));
14367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14370                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14372                 {
14373                         uint32_t _flags_save_string = ndr->flags;
14374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14375                         {
14376                                 struct ndr_pull *_ndr_extra_string;
14377                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14378                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14379                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14380                         }
14381                         ndr->flags = _flags_save_string;
14382                 }
14383         }
14384         if (ndr_flags & NDR_BUFFERS) {
14385         }
14386         return NDR_ERR_SUCCESS;
14387 }
14388
14389 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14390 {
14391         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14392         ndr->depth++;
14393         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);
14394         ndr_print_uint32(ndr, "major", r->major);
14395         ndr_print_uint32(ndr, "minor", r->minor);
14396         ndr_print_uint32(ndr, "build", r->build);
14397         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14398         ndr_print_string(ndr, "extra_string", r->extra_string);
14399         ndr->depth--;
14400 }
14401
14402 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14403 {
14404         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14405 }
14406
14407 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14408 {
14409         if (ndr_flags & NDR_SCALARS) {
14410                 NDR_CHECK(ndr_push_align(ndr, 4));
14411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14416                 {
14417                         uint32_t _flags_save_string = ndr->flags;
14418                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14419                         {
14420                                 struct ndr_push *_ndr_extra_string;
14421                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14422                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14423                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14424                         }
14425                         ndr->flags = _flags_save_string;
14426                 }
14427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14429         }
14430         if (ndr_flags & NDR_BUFFERS) {
14431         }
14432         return NDR_ERR_SUCCESS;
14433 }
14434
14435 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14436 {
14437         if (ndr_flags & NDR_SCALARS) {
14438                 NDR_CHECK(ndr_pull_align(ndr, 4));
14439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14444                 {
14445                         uint32_t _flags_save_string = ndr->flags;
14446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14447                         {
14448                                 struct ndr_pull *_ndr_extra_string;
14449                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14450                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14451                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14452                         }
14453                         ndr->flags = _flags_save_string;
14454                 }
14455                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14457         }
14458         if (ndr_flags & NDR_BUFFERS) {
14459         }
14460         return NDR_ERR_SUCCESS;
14461 }
14462
14463 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14464 {
14465         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14466         ndr->depth++;
14467         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);
14468         ndr_print_uint32(ndr, "major", r->major);
14469         ndr_print_uint32(ndr, "minor", r->minor);
14470         ndr_print_uint32(ndr, "build", r->build);
14471         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14472         ndr_print_string(ndr, "extra_string", r->extra_string);
14473         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14474         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14475         ndr->depth--;
14476 }
14477
14478 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14479 {
14480         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14481 }
14482
14483 static enum ndr_err_code ndr_push_spoolss_PrinterDataType(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterDataType r)
14484 {
14485         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14486         return NDR_ERR_SUCCESS;
14487 }
14488
14489 static enum ndr_err_code ndr_pull_spoolss_PrinterDataType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterDataType *r)
14490 {
14491         uint32_t v;
14492         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14493         *r = v;
14494         return NDR_ERR_SUCCESS;
14495 }
14496
14497 _PUBLIC_ void ndr_print_spoolss_PrinterDataType(struct ndr_print *ndr, const char *name, enum spoolss_PrinterDataType r)
14498 {
14499         const char *val = NULL;
14500
14501         switch (r) {
14502                 case SPOOLSS_PRINTER_DATA_TYPE_NULL: val = "SPOOLSS_PRINTER_DATA_TYPE_NULL"; break;
14503                 case SPOOLSS_PRINTER_DATA_TYPE_STRING: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING"; break;
14504                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY: val = "SPOOLSS_PRINTER_DATA_TYPE_BINARY"; break;
14505                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32: val = "SPOOLSS_PRINTER_DATA_TYPE_UINT32"; break;
14506                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: val = "SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY"; break;
14507         }
14508         ndr_print_enum(ndr, name, "ENUM", val, r);
14509 }
14510
14511 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14512 {
14513         if (ndr_flags & NDR_SCALARS) {
14514                 int level = ndr_push_get_switch_value(ndr, r);
14515                 switch (level) {
14516                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14517                         break; }
14518
14519                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14520                                 {
14521                                         uint32_t _flags_save_string = ndr->flags;
14522                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14523                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14524                                         ndr->flags = _flags_save_string;
14525                                 }
14526                         break; }
14527
14528                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14529                                 {
14530                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14531                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14532                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14533                                         ndr->flags = _flags_save_DATA_BLOB;
14534                                 }
14535                         break; }
14536
14537                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14538                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14539                         break; }
14540
14541                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14542                                 {
14543                                         uint32_t _flags_save_string_array = ndr->flags;
14544                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14545                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14546                                         ndr->flags = _flags_save_string_array;
14547                                 }
14548                         break; }
14549
14550                         default: {
14551                                 {
14552                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14553                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14554                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14555                                         ndr->flags = _flags_save_DATA_BLOB;
14556                                 }
14557                         break; }
14558
14559                 }
14560         }
14561         if (ndr_flags & NDR_BUFFERS) {
14562                 int level = ndr_push_get_switch_value(ndr, r);
14563                 switch (level) {
14564                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14565                         break;
14566
14567                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14568                         break;
14569
14570                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14571                         break;
14572
14573                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14574                         break;
14575
14576                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14577                         break;
14578
14579                         default:
14580                         break;
14581
14582                 }
14583         }
14584         return NDR_ERR_SUCCESS;
14585 }
14586
14587 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14588 {
14589         int level;
14590         level = ndr_pull_get_switch_value(ndr, r);
14591         if (ndr_flags & NDR_SCALARS) {
14592                 switch (level) {
14593                         case SPOOLSS_PRINTER_DATA_TYPE_NULL: {
14594                         break; }
14595
14596                         case SPOOLSS_PRINTER_DATA_TYPE_STRING: {
14597                                 {
14598                                         uint32_t _flags_save_string = ndr->flags;
14599                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14600                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14601                                         ndr->flags = _flags_save_string;
14602                                 }
14603                         break; }
14604
14605                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY: {
14606                                 {
14607                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14608                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14609                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14610                                         ndr->flags = _flags_save_DATA_BLOB;
14611                                 }
14612                         break; }
14613
14614                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32: {
14615                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14616                         break; }
14617
14618                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY: {
14619                                 {
14620                                         uint32_t _flags_save_string_array = ndr->flags;
14621                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14622                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14623                                         ndr->flags = _flags_save_string_array;
14624                                 }
14625                         break; }
14626
14627                         default: {
14628                                 {
14629                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14630                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14631                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14632                                         ndr->flags = _flags_save_DATA_BLOB;
14633                                 }
14634                         break; }
14635
14636                 }
14637         }
14638         if (ndr_flags & NDR_BUFFERS) {
14639                 switch (level) {
14640                         case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14641                         break;
14642
14643                         case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14644                         break;
14645
14646                         case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14647                         break;
14648
14649                         case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14650                         break;
14651
14652                         case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14653                         break;
14654
14655                         default:
14656                         break;
14657
14658                 }
14659         }
14660         return NDR_ERR_SUCCESS;
14661 }
14662
14663 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14664 {
14665         int level;
14666         level = ndr_print_get_switch_value(ndr, r);
14667         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14668         switch (level) {
14669                 case SPOOLSS_PRINTER_DATA_TYPE_NULL:
14670                 break;
14671
14672                 case SPOOLSS_PRINTER_DATA_TYPE_STRING:
14673                         ndr_print_string(ndr, "string", r->string);
14674                 break;
14675
14676                 case SPOOLSS_PRINTER_DATA_TYPE_BINARY:
14677                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14678                 break;
14679
14680                 case SPOOLSS_PRINTER_DATA_TYPE_UINT32:
14681                         ndr_print_uint32(ndr, "value", r->value);
14682                 break;
14683
14684                 case SPOOLSS_PRINTER_DATA_TYPE_STRING_ARRAY:
14685                         ndr_print_string_array(ndr, "string_array", r->string_array);
14686                 break;
14687
14688                 default:
14689                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14690                 break;
14691
14692         }
14693 }
14694
14695 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14696 {
14697         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14698 }
14699
14700 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14701 {
14702         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14703         return NDR_ERR_SUCCESS;
14704 }
14705
14706 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14707 {
14708         uint32_t v;
14709         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14710         *r = v;
14711         return NDR_ERR_SUCCESS;
14712 }
14713
14714 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14715 {
14716         const char *val = NULL;
14717
14718         switch (r) {
14719                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14720                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14721                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14722         }
14723         ndr_print_enum(ndr, name, "ENUM", val, r);
14724 }
14725
14726 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14727 {
14728         if (ndr_flags & NDR_SCALARS) {
14729                 NDR_CHECK(ndr_push_align(ndr, 4));
14730                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14732         }
14733         if (ndr_flags & NDR_BUFFERS) {
14734         }
14735         return NDR_ERR_SUCCESS;
14736 }
14737
14738 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14739 {
14740         if (ndr_flags & NDR_SCALARS) {
14741                 NDR_CHECK(ndr_pull_align(ndr, 4));
14742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14744         }
14745         if (ndr_flags & NDR_BUFFERS) {
14746         }
14747         return NDR_ERR_SUCCESS;
14748 }
14749
14750 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14751 {
14752         ndr_print_struct(ndr, name, "spoolss_FormSize");
14753         ndr->depth++;
14754         ndr_print_uint32(ndr, "width", r->width);
14755         ndr_print_uint32(ndr, "height", r->height);
14756         ndr->depth--;
14757 }
14758
14759 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14760 {
14761         if (ndr_flags & NDR_SCALARS) {
14762                 NDR_CHECK(ndr_push_align(ndr, 4));
14763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14767         }
14768         if (ndr_flags & NDR_BUFFERS) {
14769         }
14770         return NDR_ERR_SUCCESS;
14771 }
14772
14773 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14774 {
14775         if (ndr_flags & NDR_SCALARS) {
14776                 NDR_CHECK(ndr_pull_align(ndr, 4));
14777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14780                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14781         }
14782         if (ndr_flags & NDR_BUFFERS) {
14783         }
14784         return NDR_ERR_SUCCESS;
14785 }
14786
14787 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14788 {
14789         ndr_print_struct(ndr, name, "spoolss_FormArea");
14790         ndr->depth++;
14791         ndr_print_uint32(ndr, "left", r->left);
14792         ndr_print_uint32(ndr, "top", r->top);
14793         ndr_print_uint32(ndr, "right", r->right);
14794         ndr_print_uint32(ndr, "bottom", r->bottom);
14795         ndr->depth--;
14796 }
14797
14798 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14799 {
14800         if (ndr_flags & NDR_SCALARS) {
14801                 NDR_CHECK(ndr_push_align(ndr, 4));
14802                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14803                 {
14804                         uint32_t _flags_save_string = ndr->flags;
14805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14806                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14807                         ndr->flags = _flags_save_string;
14808                 }
14809                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14810                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14811         }
14812         if (ndr_flags & NDR_BUFFERS) {
14813                 {
14814                         uint32_t _flags_save_string = ndr->flags;
14815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14816                         if (r->form_name) {
14817                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14818                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14819                         }
14820                         ndr->flags = _flags_save_string;
14821                 }
14822         }
14823         return NDR_ERR_SUCCESS;
14824 }
14825
14826 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14827 {
14828         uint32_t _ptr_form_name;
14829         TALLOC_CTX *_mem_save_form_name_0;
14830         if (ndr_flags & NDR_SCALARS) {
14831                 NDR_CHECK(ndr_pull_align(ndr, 4));
14832                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14833                 {
14834                         uint32_t _flags_save_string = ndr->flags;
14835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14837                         if (_ptr_form_name) {
14838                                 NDR_PULL_ALLOC(ndr, r->form_name);
14839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14840                         } else {
14841                                 r->form_name = NULL;
14842                         }
14843                         ndr->flags = _flags_save_string;
14844                 }
14845                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14846                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14847         }
14848         if (ndr_flags & NDR_BUFFERS) {
14849                 {
14850                         uint32_t _flags_save_string = ndr->flags;
14851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14852                         if (r->form_name) {
14853                                 uint32_t _relative_save_offset;
14854                                 _relative_save_offset = ndr->offset;
14855                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14856                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14857                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14858                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14859                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14860                                 ndr->offset = _relative_save_offset;
14861                         }
14862                         ndr->flags = _flags_save_string;
14863                 }
14864         }
14865         return NDR_ERR_SUCCESS;
14866 }
14867
14868 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14869 {
14870         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14871         ndr->depth++;
14872         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14873         ndr_print_ptr(ndr, "form_name", r->form_name);
14874         ndr->depth++;
14875         if (r->form_name) {
14876                 ndr_print_string(ndr, "form_name", r->form_name);
14877         }
14878         ndr->depth--;
14879         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14880         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14881         ndr->depth--;
14882 }
14883
14884 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14885 {
14886         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14887 }
14888
14889 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14890 {
14891         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14892         return NDR_ERR_SUCCESS;
14893 }
14894
14895 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14896 {
14897         uint32_t v;
14898         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14899         *r = v;
14900         return NDR_ERR_SUCCESS;
14901 }
14902
14903 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14904 {
14905         ndr_print_uint32(ndr, name, r);
14906         ndr->depth++;
14907         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14908         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14909         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14910         ndr->depth--;
14911 }
14912
14913 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14914 {
14915         if (ndr_flags & NDR_SCALARS) {
14916                 NDR_CHECK(ndr_push_align(ndr, 4));
14917                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14918                 {
14919                         uint32_t _flags_save_string = ndr->flags;
14920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14921                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14922                         ndr->flags = _flags_save_string;
14923                 }
14924                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14925                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14926                 {
14927                         uint32_t _flags_save_string = ndr->flags;
14928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14929                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14930                         ndr->flags = _flags_save_string;
14931                 }
14932                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14933                 {
14934                         uint32_t _flags_save_string = ndr->flags;
14935                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14936                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14937                         ndr->flags = _flags_save_string;
14938                 }
14939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
14940                 {
14941                         uint32_t _flags_save_string = ndr->flags;
14942                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14943                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
14944                         ndr->flags = _flags_save_string;
14945                 }
14946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14947         }
14948         if (ndr_flags & NDR_BUFFERS) {
14949                 {
14950                         uint32_t _flags_save_string = ndr->flags;
14951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14952                         if (r->form_name) {
14953                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14954                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14955                         }
14956                         ndr->flags = _flags_save_string;
14957                 }
14958                 {
14959                         uint32_t _flags_save_string = ndr->flags;
14960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14961                         if (r->keyword) {
14962                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
14963                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
14964                         }
14965                         ndr->flags = _flags_save_string;
14966                 }
14967                 {
14968                         uint32_t _flags_save_string = ndr->flags;
14969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14970                         if (r->mui_dll) {
14971                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
14972                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
14973                         }
14974                         ndr->flags = _flags_save_string;
14975                 }
14976                 {
14977                         uint32_t _flags_save_string = ndr->flags;
14978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14979                         if (r->display_name) {
14980                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
14981                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
14982                         }
14983                         ndr->flags = _flags_save_string;
14984                 }
14985         }
14986         return NDR_ERR_SUCCESS;
14987 }
14988
14989 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
14990 {
14991         uint32_t _ptr_form_name;
14992         TALLOC_CTX *_mem_save_form_name_0;
14993         uint32_t _ptr_keyword;
14994         TALLOC_CTX *_mem_save_keyword_0;
14995         uint32_t _ptr_mui_dll;
14996         TALLOC_CTX *_mem_save_mui_dll_0;
14997         uint32_t _ptr_display_name;
14998         TALLOC_CTX *_mem_save_display_name_0;
14999         if (ndr_flags & NDR_SCALARS) {
15000                 NDR_CHECK(ndr_pull_align(ndr, 4));
15001                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15002                 {
15003                         uint32_t _flags_save_string = ndr->flags;
15004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15005                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15006                         if (_ptr_form_name) {
15007                                 NDR_PULL_ALLOC(ndr, r->form_name);
15008                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15009                         } else {
15010                                 r->form_name = NULL;
15011                         }
15012                         ndr->flags = _flags_save_string;
15013                 }
15014                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15015                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15016                 {
15017                         uint32_t _flags_save_string = ndr->flags;
15018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15019                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15020                         if (_ptr_keyword) {
15021                                 NDR_PULL_ALLOC(ndr, r->keyword);
15022                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15023                         } else {
15024                                 r->keyword = NULL;
15025                         }
15026                         ndr->flags = _flags_save_string;
15027                 }
15028                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15029                 {
15030                         uint32_t _flags_save_string = ndr->flags;
15031                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15032                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15033                         if (_ptr_mui_dll) {
15034                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15035                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15036                         } else {
15037                                 r->mui_dll = NULL;
15038                         }
15039                         ndr->flags = _flags_save_string;
15040                 }
15041                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15042                 {
15043                         uint32_t _flags_save_string = ndr->flags;
15044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15045                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15046                         if (_ptr_display_name) {
15047                                 NDR_PULL_ALLOC(ndr, r->display_name);
15048                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15049                         } else {
15050                                 r->display_name = NULL;
15051                         }
15052                         ndr->flags = _flags_save_string;
15053                 }
15054                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15055         }
15056         if (ndr_flags & NDR_BUFFERS) {
15057                 {
15058                         uint32_t _flags_save_string = ndr->flags;
15059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15060                         if (r->form_name) {
15061                                 uint32_t _relative_save_offset;
15062                                 _relative_save_offset = ndr->offset;
15063                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15064                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15065                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15066                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15067                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15068                                 ndr->offset = _relative_save_offset;
15069                         }
15070                         ndr->flags = _flags_save_string;
15071                 }
15072                 {
15073                         uint32_t _flags_save_string = ndr->flags;
15074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15075                         if (r->keyword) {
15076                                 uint32_t _relative_save_offset;
15077                                 _relative_save_offset = ndr->offset;
15078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15079                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15080                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15083                                 ndr->offset = _relative_save_offset;
15084                         }
15085                         ndr->flags = _flags_save_string;
15086                 }
15087                 {
15088                         uint32_t _flags_save_string = ndr->flags;
15089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15090                         if (r->mui_dll) {
15091                                 uint32_t _relative_save_offset;
15092                                 _relative_save_offset = ndr->offset;
15093                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15094                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15095                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15096                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15097                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15098                                 ndr->offset = _relative_save_offset;
15099                         }
15100                         ndr->flags = _flags_save_string;
15101                 }
15102                 {
15103                         uint32_t _flags_save_string = ndr->flags;
15104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15105                         if (r->display_name) {
15106                                 uint32_t _relative_save_offset;
15107                                 _relative_save_offset = ndr->offset;
15108                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15109                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15110                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15111                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15112                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15113                                 ndr->offset = _relative_save_offset;
15114                         }
15115                         ndr->flags = _flags_save_string;
15116                 }
15117         }
15118         return NDR_ERR_SUCCESS;
15119 }
15120
15121 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15122 {
15123         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15124         ndr->depth++;
15125         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15126         ndr_print_ptr(ndr, "form_name", r->form_name);
15127         ndr->depth++;
15128         if (r->form_name) {
15129                 ndr_print_string(ndr, "form_name", r->form_name);
15130         }
15131         ndr->depth--;
15132         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15133         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15134         ndr_print_ptr(ndr, "keyword", r->keyword);
15135         ndr->depth++;
15136         if (r->keyword) {
15137                 ndr_print_string(ndr, "keyword", r->keyword);
15138         }
15139         ndr->depth--;
15140         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15141         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15142         ndr->depth++;
15143         if (r->mui_dll) {
15144                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15145         }
15146         ndr->depth--;
15147         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15148         ndr_print_ptr(ndr, "display_name", r->display_name);
15149         ndr->depth++;
15150         if (r->display_name) {
15151                 ndr_print_string(ndr, "display_name", r->display_name);
15152         }
15153         ndr->depth--;
15154         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15155         ndr->depth--;
15156 }
15157
15158 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15159 {
15160         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15161 }
15162
15163 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15164 {
15165         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15166         if (ndr_flags & NDR_SCALARS) {
15167                 int level = ndr_push_get_switch_value(ndr, r);
15168                 switch (level) {
15169                         case 1: {
15170                                 NDR_CHECK(ndr_push_align(ndr, 4));
15171                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15172                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15173                         break; }
15174
15175                         case 2: {
15176                                 NDR_CHECK(ndr_push_align(ndr, 4));
15177                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15178                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15179                         break; }
15180
15181                         default: {
15182                         break; }
15183
15184                 }
15185         }
15186         if (ndr_flags & NDR_BUFFERS) {
15187                 int level = ndr_push_get_switch_value(ndr, r);
15188                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15189                 switch (level) {
15190                         case 1:
15191                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15192                         break;
15193
15194                         case 2:
15195                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15196                         break;
15197
15198                         default:
15199                         break;
15200
15201                 }
15202         }
15203         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15204         return NDR_ERR_SUCCESS;
15205 }
15206
15207 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15208 {
15209         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15210         int level;
15211         level = ndr_pull_get_switch_value(ndr, r);
15212         if (ndr_flags & NDR_SCALARS) {
15213                 switch (level) {
15214                         case 1: {
15215                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15216                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15217                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15218                         break; }
15219
15220                         case 2: {
15221                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15222                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15223                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15224                         break; }
15225
15226                         default: {
15227                         break; }
15228
15229                 }
15230         }
15231         if (ndr_flags & NDR_BUFFERS) {
15232                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15233                 switch (level) {
15234                         case 1:
15235                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15236                         break;
15237
15238                         case 2:
15239                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15240                         break;
15241
15242                         default:
15243                         break;
15244
15245                 }
15246         }
15247         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15248         return NDR_ERR_SUCCESS;
15249 }
15250
15251 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15252 {
15253         int level;
15254         level = ndr_print_get_switch_value(ndr, r);
15255         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15256         switch (level) {
15257                 case 1:
15258                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15259                 break;
15260
15261                 case 2:
15262                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15263                 break;
15264
15265                 default:
15266                 break;
15267
15268         }
15269 }
15270
15271 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15272 {
15273         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15274 }
15275
15276 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15277 {
15278         if (ndr_flags & NDR_SCALARS) {
15279                 NDR_CHECK(ndr_push_align(ndr, 4));
15280                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15281                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15282                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15283                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15284         }
15285         if (ndr_flags & NDR_BUFFERS) {
15286                 if (r->form_name) {
15287                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15288                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15290                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15291                 }
15292         }
15293         return NDR_ERR_SUCCESS;
15294 }
15295
15296 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15297 {
15298         uint32_t _ptr_form_name;
15299         TALLOC_CTX *_mem_save_form_name_0;
15300         if (ndr_flags & NDR_SCALARS) {
15301                 NDR_CHECK(ndr_pull_align(ndr, 4));
15302                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15303                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15304                 if (_ptr_form_name) {
15305                         NDR_PULL_ALLOC(ndr, r->form_name);
15306                 } else {
15307                         r->form_name = NULL;
15308                 }
15309                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15310                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15311         }
15312         if (ndr_flags & NDR_BUFFERS) {
15313                 if (r->form_name) {
15314                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15315                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15316                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15317                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15318                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15319                                 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));
15320                         }
15321                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15322                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15324                 }
15325         }
15326         return NDR_ERR_SUCCESS;
15327 }
15328
15329 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15330 {
15331         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15332         ndr->depth++;
15333         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15334         ndr_print_ptr(ndr, "form_name", r->form_name);
15335         ndr->depth++;
15336         if (r->form_name) {
15337                 ndr_print_string(ndr, "form_name", r->form_name);
15338         }
15339         ndr->depth--;
15340         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15341         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15342         ndr->depth--;
15343 }
15344
15345 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15346 {
15347         if (ndr_flags & NDR_SCALARS) {
15348                 NDR_CHECK(ndr_push_align(ndr, 4));
15349                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15351                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15352                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15354                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15355                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15356                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15359         }
15360         if (ndr_flags & NDR_BUFFERS) {
15361                 if (r->form_name) {
15362                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15365                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15366                 }
15367                 if (r->keyword) {
15368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15370                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15371                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15372                 }
15373                 if (r->mui_dll) {
15374                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15375                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15376                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15377                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15378                 }
15379                 if (r->display_name) {
15380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15381                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15382                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15383                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15384                 }
15385         }
15386         return NDR_ERR_SUCCESS;
15387 }
15388
15389 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15390 {
15391         uint32_t _ptr_form_name;
15392         TALLOC_CTX *_mem_save_form_name_0;
15393         uint32_t _ptr_keyword;
15394         TALLOC_CTX *_mem_save_keyword_0;
15395         uint32_t _ptr_mui_dll;
15396         TALLOC_CTX *_mem_save_mui_dll_0;
15397         uint32_t _ptr_display_name;
15398         TALLOC_CTX *_mem_save_display_name_0;
15399         if (ndr_flags & NDR_SCALARS) {
15400                 NDR_CHECK(ndr_pull_align(ndr, 4));
15401                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15402                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15403                 if (_ptr_form_name) {
15404                         NDR_PULL_ALLOC(ndr, r->form_name);
15405                 } else {
15406                         r->form_name = NULL;
15407                 }
15408                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15409                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15411                 if (_ptr_keyword) {
15412                         NDR_PULL_ALLOC(ndr, r->keyword);
15413                 } else {
15414                         r->keyword = NULL;
15415                 }
15416                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15417                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15418                 if (_ptr_mui_dll) {
15419                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15420                 } else {
15421                         r->mui_dll = NULL;
15422                 }
15423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15424                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15425                 if (_ptr_display_name) {
15426                         NDR_PULL_ALLOC(ndr, r->display_name);
15427                 } else {
15428                         r->display_name = NULL;
15429                 }
15430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15431         }
15432         if (ndr_flags & NDR_BUFFERS) {
15433                 if (r->form_name) {
15434                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15435                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15436                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15437                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15438                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15439                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
15440                         }
15441                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15442                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15444                 }
15445                 if (r->keyword) {
15446                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15447                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15448                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15449                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15450                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15451                                 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));
15452                         }
15453                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15454                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15455                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15456                 }
15457                 if (r->mui_dll) {
15458                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15459                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15460                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15461                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15462                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15463                                 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));
15464                         }
15465                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15466                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15467                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15468                 }
15469                 if (r->display_name) {
15470                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15471                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15472                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15473                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15474                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15475                                 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));
15476                         }
15477                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15478                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15479                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15480                 }
15481         }
15482         return NDR_ERR_SUCCESS;
15483 }
15484
15485 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15486 {
15487         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15488         ndr->depth++;
15489         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15490         ndr_print_ptr(ndr, "form_name", r->form_name);
15491         ndr->depth++;
15492         if (r->form_name) {
15493                 ndr_print_string(ndr, "form_name", r->form_name);
15494         }
15495         ndr->depth--;
15496         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15497         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15498         ndr_print_ptr(ndr, "keyword", r->keyword);
15499         ndr->depth++;
15500         if (r->keyword) {
15501                 ndr_print_string(ndr, "keyword", r->keyword);
15502         }
15503         ndr->depth--;
15504         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15505         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15506         ndr->depth++;
15507         if (r->mui_dll) {
15508                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15509         }
15510         ndr->depth--;
15511         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15512         ndr_print_ptr(ndr, "display_name", r->display_name);
15513         ndr->depth++;
15514         if (r->display_name) {
15515                 ndr_print_string(ndr, "display_name", r->display_name);
15516         }
15517         ndr->depth--;
15518         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15519         ndr->depth--;
15520 }
15521
15522 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15523 {
15524         if (ndr_flags & NDR_SCALARS) {
15525                 int level = ndr_push_get_switch_value(ndr, r);
15526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15527                 switch (level) {
15528                         case 1: {
15529                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15530                         break; }
15531
15532                         case 2: {
15533                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15534                         break; }
15535
15536                         default:
15537                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15538                 }
15539         }
15540         if (ndr_flags & NDR_BUFFERS) {
15541                 int level = ndr_push_get_switch_value(ndr, r);
15542                 switch (level) {
15543                         case 1:
15544                                 if (r->info1) {
15545                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15546                                 }
15547                         break;
15548
15549                         case 2:
15550                                 if (r->info2) {
15551                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15552                                 }
15553                         break;
15554
15555                         default:
15556                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15557                 }
15558         }
15559         return NDR_ERR_SUCCESS;
15560 }
15561
15562 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15563 {
15564         int level;
15565         uint32_t _level;
15566         TALLOC_CTX *_mem_save_info1_0;
15567         TALLOC_CTX *_mem_save_info2_0;
15568         level = ndr_pull_get_switch_value(ndr, r);
15569         if (ndr_flags & NDR_SCALARS) {
15570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15571                 if (_level != level) {
15572                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15573                 }
15574                 switch (level) {
15575                         case 1: {
15576                                 uint32_t _ptr_info1;
15577                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15578                                 if (_ptr_info1) {
15579                                         NDR_PULL_ALLOC(ndr, r->info1);
15580                                 } else {
15581                                         r->info1 = NULL;
15582                                 }
15583                         break; }
15584
15585                         case 2: {
15586                                 uint32_t _ptr_info2;
15587                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15588                                 if (_ptr_info2) {
15589                                         NDR_PULL_ALLOC(ndr, r->info2);
15590                                 } else {
15591                                         r->info2 = NULL;
15592                                 }
15593                         break; }
15594
15595                         default:
15596                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15597                 }
15598         }
15599         if (ndr_flags & NDR_BUFFERS) {
15600                 switch (level) {
15601                         case 1:
15602                                 if (r->info1) {
15603                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15604                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15605                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15606                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15607                                 }
15608                         break;
15609
15610                         case 2:
15611                                 if (r->info2) {
15612                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15613                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15614                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15615                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15616                                 }
15617                         break;
15618
15619                         default:
15620                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15621                 }
15622         }
15623         return NDR_ERR_SUCCESS;
15624 }
15625
15626 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15627 {
15628         int level;
15629         level = ndr_print_get_switch_value(ndr, r);
15630         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15631         switch (level) {
15632                 case 1:
15633                         ndr_print_ptr(ndr, "info1", r->info1);
15634                         ndr->depth++;
15635                         if (r->info1) {
15636                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15637                         }
15638                         ndr->depth--;
15639                 break;
15640
15641                 case 2:
15642                         ndr_print_ptr(ndr, "info2", r->info2);
15643                         ndr->depth++;
15644                         if (r->info2) {
15645                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15646                         }
15647                         ndr->depth--;
15648                 break;
15649
15650                 default:
15651                         ndr_print_bad_level(ndr, name, level);
15652         }
15653 }
15654
15655 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15656 {
15657         if (ndr_flags & NDR_SCALARS) {
15658                 NDR_CHECK(ndr_push_align(ndr, 4));
15659                 {
15660                         uint32_t _flags_save_string = ndr->flags;
15661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15662                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15663                         ndr->flags = _flags_save_string;
15664                 }
15665         }
15666         if (ndr_flags & NDR_BUFFERS) {
15667                 {
15668                         uint32_t _flags_save_string = ndr->flags;
15669                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15670                         if (r->port_name) {
15671                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15672                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15673                         }
15674                         ndr->flags = _flags_save_string;
15675                 }
15676         }
15677         return NDR_ERR_SUCCESS;
15678 }
15679
15680 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15681 {
15682         uint32_t _ptr_port_name;
15683         TALLOC_CTX *_mem_save_port_name_0;
15684         if (ndr_flags & NDR_SCALARS) {
15685                 NDR_CHECK(ndr_pull_align(ndr, 4));
15686                 {
15687                         uint32_t _flags_save_string = ndr->flags;
15688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15689                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15690                         if (_ptr_port_name) {
15691                                 NDR_PULL_ALLOC(ndr, r->port_name);
15692                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15693                         } else {
15694                                 r->port_name = NULL;
15695                         }
15696                         ndr->flags = _flags_save_string;
15697                 }
15698         }
15699         if (ndr_flags & NDR_BUFFERS) {
15700                 {
15701                         uint32_t _flags_save_string = ndr->flags;
15702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15703                         if (r->port_name) {
15704                                 uint32_t _relative_save_offset;
15705                                 _relative_save_offset = ndr->offset;
15706                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15707                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15708                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15709                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15710                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15711                                 ndr->offset = _relative_save_offset;
15712                         }
15713                         ndr->flags = _flags_save_string;
15714                 }
15715         }
15716         return NDR_ERR_SUCCESS;
15717 }
15718
15719 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15720 {
15721         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15722         ndr->depth++;
15723         ndr_print_ptr(ndr, "port_name", r->port_name);
15724         ndr->depth++;
15725         if (r->port_name) {
15726                 ndr_print_string(ndr, "port_name", r->port_name);
15727         }
15728         ndr->depth--;
15729         ndr->depth--;
15730 }
15731
15732 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15733 {
15734         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15735 }
15736
15737 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15738 {
15739         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15740         return NDR_ERR_SUCCESS;
15741 }
15742
15743 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15744 {
15745         uint32_t v;
15746         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15747         *r = v;
15748         return NDR_ERR_SUCCESS;
15749 }
15750
15751 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15752 {
15753         ndr_print_uint32(ndr, name, r);
15754         ndr->depth++;
15755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15759         ndr->depth--;
15760 }
15761
15762 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15763 {
15764         if (ndr_flags & NDR_SCALARS) {
15765                 NDR_CHECK(ndr_push_align(ndr, 4));
15766                 {
15767                         uint32_t _flags_save_string = ndr->flags;
15768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15769                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15770                         ndr->flags = _flags_save_string;
15771                 }
15772                 {
15773                         uint32_t _flags_save_string = ndr->flags;
15774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15775                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15776                         ndr->flags = _flags_save_string;
15777                 }
15778                 {
15779                         uint32_t _flags_save_string = ndr->flags;
15780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15782                         ndr->flags = _flags_save_string;
15783                 }
15784                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15786         }
15787         if (ndr_flags & NDR_BUFFERS) {
15788                 {
15789                         uint32_t _flags_save_string = ndr->flags;
15790                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15791                         if (r->port_name) {
15792                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15793                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15794                         }
15795                         ndr->flags = _flags_save_string;
15796                 }
15797                 {
15798                         uint32_t _flags_save_string = ndr->flags;
15799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15800                         if (r->monitor_name) {
15801                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15802                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15803                         }
15804                         ndr->flags = _flags_save_string;
15805                 }
15806                 {
15807                         uint32_t _flags_save_string = ndr->flags;
15808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15809                         if (r->description) {
15810                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15811                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15812                         }
15813                         ndr->flags = _flags_save_string;
15814                 }
15815         }
15816         return NDR_ERR_SUCCESS;
15817 }
15818
15819 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15820 {
15821         uint32_t _ptr_port_name;
15822         TALLOC_CTX *_mem_save_port_name_0;
15823         uint32_t _ptr_monitor_name;
15824         TALLOC_CTX *_mem_save_monitor_name_0;
15825         uint32_t _ptr_description;
15826         TALLOC_CTX *_mem_save_description_0;
15827         if (ndr_flags & NDR_SCALARS) {
15828                 NDR_CHECK(ndr_pull_align(ndr, 4));
15829                 {
15830                         uint32_t _flags_save_string = ndr->flags;
15831                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15832                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15833                         if (_ptr_port_name) {
15834                                 NDR_PULL_ALLOC(ndr, r->port_name);
15835                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15836                         } else {
15837                                 r->port_name = NULL;
15838                         }
15839                         ndr->flags = _flags_save_string;
15840                 }
15841                 {
15842                         uint32_t _flags_save_string = ndr->flags;
15843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15844                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15845                         if (_ptr_monitor_name) {
15846                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15847                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15848                         } else {
15849                                 r->monitor_name = NULL;
15850                         }
15851                         ndr->flags = _flags_save_string;
15852                 }
15853                 {
15854                         uint32_t _flags_save_string = ndr->flags;
15855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15856                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15857                         if (_ptr_description) {
15858                                 NDR_PULL_ALLOC(ndr, r->description);
15859                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15860                         } else {
15861                                 r->description = NULL;
15862                         }
15863                         ndr->flags = _flags_save_string;
15864                 }
15865                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15867         }
15868         if (ndr_flags & NDR_BUFFERS) {
15869                 {
15870                         uint32_t _flags_save_string = ndr->flags;
15871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15872                         if (r->port_name) {
15873                                 uint32_t _relative_save_offset;
15874                                 _relative_save_offset = ndr->offset;
15875                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15876                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15877                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15878                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15879                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15880                                 ndr->offset = _relative_save_offset;
15881                         }
15882                         ndr->flags = _flags_save_string;
15883                 }
15884                 {
15885                         uint32_t _flags_save_string = ndr->flags;
15886                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15887                         if (r->monitor_name) {
15888                                 uint32_t _relative_save_offset;
15889                                 _relative_save_offset = ndr->offset;
15890                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15891                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15892                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15893                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15894                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15895                                 ndr->offset = _relative_save_offset;
15896                         }
15897                         ndr->flags = _flags_save_string;
15898                 }
15899                 {
15900                         uint32_t _flags_save_string = ndr->flags;
15901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15902                         if (r->description) {
15903                                 uint32_t _relative_save_offset;
15904                                 _relative_save_offset = ndr->offset;
15905                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15906                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15907                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15908                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15909                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15910                                 ndr->offset = _relative_save_offset;
15911                         }
15912                         ndr->flags = _flags_save_string;
15913                 }
15914         }
15915         return NDR_ERR_SUCCESS;
15916 }
15917
15918 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15919 {
15920         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15921         ndr->depth++;
15922         ndr_print_ptr(ndr, "port_name", r->port_name);
15923         ndr->depth++;
15924         if (r->port_name) {
15925                 ndr_print_string(ndr, "port_name", r->port_name);
15926         }
15927         ndr->depth--;
15928         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15929         ndr->depth++;
15930         if (r->monitor_name) {
15931                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15932         }
15933         ndr->depth--;
15934         ndr_print_ptr(ndr, "description", r->description);
15935         ndr->depth++;
15936         if (r->description) {
15937                 ndr_print_string(ndr, "description", r->description);
15938         }
15939         ndr->depth--;
15940         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15941         ndr_print_uint32(ndr, "reserved", r->reserved);
15942         ndr->depth--;
15943 }
15944
15945 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15946 {
15947         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
15948 }
15949
15950 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
15951 {
15952         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15953         return NDR_ERR_SUCCESS;
15954 }
15955
15956 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
15957 {
15958         uint32_t v;
15959         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15960         *r = v;
15961         return NDR_ERR_SUCCESS;
15962 }
15963
15964 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
15965 {
15966         const char *val = NULL;
15967
15968         switch (r) {
15969                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
15970                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
15971                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
15972                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
15973                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
15974                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
15975                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
15976                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
15977                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
15978                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
15979                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
15980                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
15981                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
15982         }
15983         ndr_print_enum(ndr, name, "ENUM", val, r);
15984 }
15985
15986 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
15987 {
15988         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15989         return NDR_ERR_SUCCESS;
15990 }
15991
15992 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
15993 {
15994         uint32_t v;
15995         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15996         *r = v;
15997         return NDR_ERR_SUCCESS;
15998 }
15999
16000 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16001 {
16002         const char *val = NULL;
16003
16004         switch (r) {
16005                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16006                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16007                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16008         }
16009         ndr_print_enum(ndr, name, "ENUM", val, r);
16010 }
16011
16012 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16013 {
16014         if (ndr_flags & NDR_SCALARS) {
16015                 NDR_CHECK(ndr_push_align(ndr, 4));
16016                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16017                 {
16018                         uint32_t _flags_save_string = ndr->flags;
16019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16020                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16021                         ndr->flags = _flags_save_string;
16022                 }
16023                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16024         }
16025         if (ndr_flags & NDR_BUFFERS) {
16026                 {
16027                         uint32_t _flags_save_string = ndr->flags;
16028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16029                         if (r->status_string) {
16030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16032                         }
16033                         ndr->flags = _flags_save_string;
16034                 }
16035         }
16036         return NDR_ERR_SUCCESS;
16037 }
16038
16039 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16040 {
16041         uint32_t _ptr_status_string;
16042         TALLOC_CTX *_mem_save_status_string_0;
16043         if (ndr_flags & NDR_SCALARS) {
16044                 NDR_CHECK(ndr_pull_align(ndr, 4));
16045                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16046                 {
16047                         uint32_t _flags_save_string = ndr->flags;
16048                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16049                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16050                         if (_ptr_status_string) {
16051                                 NDR_PULL_ALLOC(ndr, r->status_string);
16052                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16053                         } else {
16054                                 r->status_string = NULL;
16055                         }
16056                         ndr->flags = _flags_save_string;
16057                 }
16058                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16059         }
16060         if (ndr_flags & NDR_BUFFERS) {
16061                 {
16062                         uint32_t _flags_save_string = ndr->flags;
16063                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16064                         if (r->status_string) {
16065                                 uint32_t _relative_save_offset;
16066                                 _relative_save_offset = ndr->offset;
16067                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16068                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16069                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16070                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16071                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16072                                 ndr->offset = _relative_save_offset;
16073                         }
16074                         ndr->flags = _flags_save_string;
16075                 }
16076         }
16077         return NDR_ERR_SUCCESS;
16078 }
16079
16080 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16081 {
16082         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16083         ndr->depth++;
16084         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16085         ndr_print_ptr(ndr, "status_string", r->status_string);
16086         ndr->depth++;
16087         if (r->status_string) {
16088                 ndr_print_string(ndr, "status_string", r->status_string);
16089         }
16090         ndr->depth--;
16091         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16092         ndr->depth--;
16093 }
16094
16095 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16096 {
16097         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16098 }
16099
16100 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16101 {
16102         if (ndr_flags & NDR_SCALARS) {
16103                 NDR_CHECK(ndr_push_align(ndr, 4));
16104                 {
16105                         uint32_t _flags_save_string = ndr->flags;
16106                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16107                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16108                         ndr->flags = _flags_save_string;
16109                 }
16110                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16111         }
16112         if (ndr_flags & NDR_BUFFERS) {
16113                 {
16114                         uint32_t _flags_save_string = ndr->flags;
16115                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16116                         if (r->port_name) {
16117                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16118                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16119                         }
16120                         ndr->flags = _flags_save_string;
16121                 }
16122         }
16123         return NDR_ERR_SUCCESS;
16124 }
16125
16126 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16127 {
16128         uint32_t _ptr_port_name;
16129         TALLOC_CTX *_mem_save_port_name_0;
16130         if (ndr_flags & NDR_SCALARS) {
16131                 NDR_CHECK(ndr_pull_align(ndr, 4));
16132                 {
16133                         uint32_t _flags_save_string = ndr->flags;
16134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16135                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16136                         if (_ptr_port_name) {
16137                                 NDR_PULL_ALLOC(ndr, r->port_name);
16138                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16139                         } else {
16140                                 r->port_name = NULL;
16141                         }
16142                         ndr->flags = _flags_save_string;
16143                 }
16144                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16145         }
16146         if (ndr_flags & NDR_BUFFERS) {
16147                 {
16148                         uint32_t _flags_save_string = ndr->flags;
16149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16150                         if (r->port_name) {
16151                                 uint32_t _relative_save_offset;
16152                                 _relative_save_offset = ndr->offset;
16153                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16154                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16155                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16156                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16157                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16158                                 ndr->offset = _relative_save_offset;
16159                         }
16160                         ndr->flags = _flags_save_string;
16161                 }
16162         }
16163         return NDR_ERR_SUCCESS;
16164 }
16165
16166 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16167 {
16168         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16169         ndr->depth++;
16170         ndr_print_ptr(ndr, "port_name", r->port_name);
16171         ndr->depth++;
16172         if (r->port_name) {
16173                 ndr_print_string(ndr, "port_name", r->port_name);
16174         }
16175         ndr->depth--;
16176         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16177         ndr->depth--;
16178 }
16179
16180 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16181 {
16182         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16183 }
16184
16185 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16186 {
16187         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16188         if (ndr_flags & NDR_SCALARS) {
16189                 int level = ndr_push_get_switch_value(ndr, r);
16190                 switch (level) {
16191                         case 1: {
16192                                 NDR_CHECK(ndr_push_align(ndr, 4));
16193                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16194                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16195                         break; }
16196
16197                         case 2: {
16198                                 NDR_CHECK(ndr_push_align(ndr, 4));
16199                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16200                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16201                         break; }
16202
16203                         case 3: {
16204                                 NDR_CHECK(ndr_push_align(ndr, 4));
16205                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16206                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16207                         break; }
16208
16209                         case 0xff: {
16210                                 NDR_CHECK(ndr_push_align(ndr, 4));
16211                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16212                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16213                         break; }
16214
16215                         default: {
16216                         break; }
16217
16218                 }
16219         }
16220         if (ndr_flags & NDR_BUFFERS) {
16221                 int level = ndr_push_get_switch_value(ndr, r);
16222                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16223                 switch (level) {
16224                         case 1:
16225                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16226                         break;
16227
16228                         case 2:
16229                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16230                         break;
16231
16232                         case 3:
16233                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16234                         break;
16235
16236                         case 0xff:
16237                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16238                         break;
16239
16240                         default:
16241                         break;
16242
16243                 }
16244         }
16245         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16246         return NDR_ERR_SUCCESS;
16247 }
16248
16249 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16250 {
16251         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16252         int level;
16253         level = ndr_pull_get_switch_value(ndr, r);
16254         if (ndr_flags & NDR_SCALARS) {
16255                 switch (level) {
16256                         case 1: {
16257                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16258                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16259                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16260                         break; }
16261
16262                         case 2: {
16263                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16264                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16265                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16266                         break; }
16267
16268                         case 3: {
16269                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16270                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16271                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16272                         break; }
16273
16274                         case 0xff: {
16275                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16276                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16277                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16278                         break; }
16279
16280                         default: {
16281                         break; }
16282
16283                 }
16284         }
16285         if (ndr_flags & NDR_BUFFERS) {
16286                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16287                 switch (level) {
16288                         case 1:
16289                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16290                         break;
16291
16292                         case 2:
16293                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16294                         break;
16295
16296                         case 3:
16297                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16298                         break;
16299
16300                         case 0xff:
16301                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16302                         break;
16303
16304                         default:
16305                         break;
16306
16307                 }
16308         }
16309         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16310         return NDR_ERR_SUCCESS;
16311 }
16312
16313 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16314 {
16315         int level;
16316         level = ndr_print_get_switch_value(ndr, r);
16317         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16318         switch (level) {
16319                 case 1:
16320                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16321                 break;
16322
16323                 case 2:
16324                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16325                 break;
16326
16327                 case 3:
16328                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16329                 break;
16330
16331                 case 0xff:
16332                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16333                 break;
16334
16335                 default:
16336                 break;
16337
16338         }
16339 }
16340
16341 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16342 {
16343         if (ndr_flags & NDR_SCALARS) {
16344                 NDR_CHECK(ndr_push_align(ndr, 4));
16345                 {
16346                         uint32_t _flags_save_string = ndr->flags;
16347                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16348                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16349                         ndr->flags = _flags_save_string;
16350                 }
16351         }
16352         if (ndr_flags & NDR_BUFFERS) {
16353                 {
16354                         uint32_t _flags_save_string = ndr->flags;
16355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16356                         if (r->monitor_name) {
16357                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16358                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16359                         }
16360                         ndr->flags = _flags_save_string;
16361                 }
16362         }
16363         return NDR_ERR_SUCCESS;
16364 }
16365
16366 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16367 {
16368         uint32_t _ptr_monitor_name;
16369         TALLOC_CTX *_mem_save_monitor_name_0;
16370         if (ndr_flags & NDR_SCALARS) {
16371                 NDR_CHECK(ndr_pull_align(ndr, 4));
16372                 {
16373                         uint32_t _flags_save_string = ndr->flags;
16374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16375                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16376                         if (_ptr_monitor_name) {
16377                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16379                         } else {
16380                                 r->monitor_name = NULL;
16381                         }
16382                         ndr->flags = _flags_save_string;
16383                 }
16384         }
16385         if (ndr_flags & NDR_BUFFERS) {
16386                 {
16387                         uint32_t _flags_save_string = ndr->flags;
16388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16389                         if (r->monitor_name) {
16390                                 uint32_t _relative_save_offset;
16391                                 _relative_save_offset = ndr->offset;
16392                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16393                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16394                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16395                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16396                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16397                                 ndr->offset = _relative_save_offset;
16398                         }
16399                         ndr->flags = _flags_save_string;
16400                 }
16401         }
16402         return NDR_ERR_SUCCESS;
16403 }
16404
16405 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16406 {
16407         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16408         ndr->depth++;
16409         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16410         ndr->depth++;
16411         if (r->monitor_name) {
16412                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16413         }
16414         ndr->depth--;
16415         ndr->depth--;
16416 }
16417
16418 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16419 {
16420         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16421 }
16422
16423 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16424 {
16425         if (ndr_flags & NDR_SCALARS) {
16426                 NDR_CHECK(ndr_push_align(ndr, 4));
16427                 {
16428                         uint32_t _flags_save_string = ndr->flags;
16429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16430                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16431                         ndr->flags = _flags_save_string;
16432                 }
16433                 {
16434                         uint32_t _flags_save_string = ndr->flags;
16435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16436                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16437                         ndr->flags = _flags_save_string;
16438                 }
16439                 {
16440                         uint32_t _flags_save_string = ndr->flags;
16441                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16442                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16443                         ndr->flags = _flags_save_string;
16444                 }
16445         }
16446         if (ndr_flags & NDR_BUFFERS) {
16447                 {
16448                         uint32_t _flags_save_string = ndr->flags;
16449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16450                         if (r->monitor_name) {
16451                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16452                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16453                         }
16454                         ndr->flags = _flags_save_string;
16455                 }
16456                 {
16457                         uint32_t _flags_save_string = ndr->flags;
16458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16459                         if (r->environment) {
16460                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16461                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16462                         }
16463                         ndr->flags = _flags_save_string;
16464                 }
16465                 {
16466                         uint32_t _flags_save_string = ndr->flags;
16467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16468                         if (r->dll_name) {
16469                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16470                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16471                         }
16472                         ndr->flags = _flags_save_string;
16473                 }
16474         }
16475         return NDR_ERR_SUCCESS;
16476 }
16477
16478 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16479 {
16480         uint32_t _ptr_monitor_name;
16481         TALLOC_CTX *_mem_save_monitor_name_0;
16482         uint32_t _ptr_environment;
16483         TALLOC_CTX *_mem_save_environment_0;
16484         uint32_t _ptr_dll_name;
16485         TALLOC_CTX *_mem_save_dll_name_0;
16486         if (ndr_flags & NDR_SCALARS) {
16487                 NDR_CHECK(ndr_pull_align(ndr, 4));
16488                 {
16489                         uint32_t _flags_save_string = ndr->flags;
16490                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16491                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16492                         if (_ptr_monitor_name) {
16493                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16494                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16495                         } else {
16496                                 r->monitor_name = NULL;
16497                         }
16498                         ndr->flags = _flags_save_string;
16499                 }
16500                 {
16501                         uint32_t _flags_save_string = ndr->flags;
16502                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16503                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16504                         if (_ptr_environment) {
16505                                 NDR_PULL_ALLOC(ndr, r->environment);
16506                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16507                         } else {
16508                                 r->environment = NULL;
16509                         }
16510                         ndr->flags = _flags_save_string;
16511                 }
16512                 {
16513                         uint32_t _flags_save_string = ndr->flags;
16514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16515                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16516                         if (_ptr_dll_name) {
16517                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16518                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16519                         } else {
16520                                 r->dll_name = NULL;
16521                         }
16522                         ndr->flags = _flags_save_string;
16523                 }
16524         }
16525         if (ndr_flags & NDR_BUFFERS) {
16526                 {
16527                         uint32_t _flags_save_string = ndr->flags;
16528                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16529                         if (r->monitor_name) {
16530                                 uint32_t _relative_save_offset;
16531                                 _relative_save_offset = ndr->offset;
16532                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16533                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16534                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16535                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16536                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16537                                 ndr->offset = _relative_save_offset;
16538                         }
16539                         ndr->flags = _flags_save_string;
16540                 }
16541                 {
16542                         uint32_t _flags_save_string = ndr->flags;
16543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16544                         if (r->environment) {
16545                                 uint32_t _relative_save_offset;
16546                                 _relative_save_offset = ndr->offset;
16547                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16548                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16549                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16550                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16551                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16552                                 ndr->offset = _relative_save_offset;
16553                         }
16554                         ndr->flags = _flags_save_string;
16555                 }
16556                 {
16557                         uint32_t _flags_save_string = ndr->flags;
16558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16559                         if (r->dll_name) {
16560                                 uint32_t _relative_save_offset;
16561                                 _relative_save_offset = ndr->offset;
16562                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16563                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16564                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16565                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16566                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16567                                 ndr->offset = _relative_save_offset;
16568                         }
16569                         ndr->flags = _flags_save_string;
16570                 }
16571         }
16572         return NDR_ERR_SUCCESS;
16573 }
16574
16575 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16576 {
16577         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16578         ndr->depth++;
16579         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16580         ndr->depth++;
16581         if (r->monitor_name) {
16582                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16583         }
16584         ndr->depth--;
16585         ndr_print_ptr(ndr, "environment", r->environment);
16586         ndr->depth++;
16587         if (r->environment) {
16588                 ndr_print_string(ndr, "environment", r->environment);
16589         }
16590         ndr->depth--;
16591         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16592         ndr->depth++;
16593         if (r->dll_name) {
16594                 ndr_print_string(ndr, "dll_name", r->dll_name);
16595         }
16596         ndr->depth--;
16597         ndr->depth--;
16598 }
16599
16600 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16601 {
16602         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16603 }
16604
16605 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16606 {
16607         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16608         if (ndr_flags & NDR_SCALARS) {
16609                 int level = ndr_push_get_switch_value(ndr, r);
16610                 switch (level) {
16611                         case 1: {
16612                                 NDR_CHECK(ndr_push_align(ndr, 4));
16613                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16614                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16615                         break; }
16616
16617                         case 2: {
16618                                 NDR_CHECK(ndr_push_align(ndr, 4));
16619                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16620                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16621                         break; }
16622
16623                         default: {
16624                         break; }
16625
16626                 }
16627         }
16628         if (ndr_flags & NDR_BUFFERS) {
16629                 int level = ndr_push_get_switch_value(ndr, r);
16630                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16631                 switch (level) {
16632                         case 1:
16633                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16634                         break;
16635
16636                         case 2:
16637                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16638                         break;
16639
16640                         default:
16641                         break;
16642
16643                 }
16644         }
16645         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16646         return NDR_ERR_SUCCESS;
16647 }
16648
16649 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16650 {
16651         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16652         int level;
16653         level = ndr_pull_get_switch_value(ndr, r);
16654         if (ndr_flags & NDR_SCALARS) {
16655                 switch (level) {
16656                         case 1: {
16657                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16658                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16659                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16660                         break; }
16661
16662                         case 2: {
16663                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16664                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16665                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16666                         break; }
16667
16668                         default: {
16669                         break; }
16670
16671                 }
16672         }
16673         if (ndr_flags & NDR_BUFFERS) {
16674                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16675                 switch (level) {
16676                         case 1:
16677                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16678                         break;
16679
16680                         case 2:
16681                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16682                         break;
16683
16684                         default:
16685                         break;
16686
16687                 }
16688         }
16689         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16690         return NDR_ERR_SUCCESS;
16691 }
16692
16693 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16694 {
16695         int level;
16696         level = ndr_print_get_switch_value(ndr, r);
16697         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16698         switch (level) {
16699                 case 1:
16700                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16701                 break;
16702
16703                 case 2:
16704                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16705                 break;
16706
16707                 default:
16708                 break;
16709
16710         }
16711 }
16712
16713 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16714 {
16715         if (ndr_flags & NDR_SCALARS) {
16716                 NDR_CHECK(ndr_push_align(ndr, 4));
16717                 {
16718                         uint32_t _flags_save_string = ndr->flags;
16719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16720                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16721                         ndr->flags = _flags_save_string;
16722                 }
16723         }
16724         if (ndr_flags & NDR_BUFFERS) {
16725                 {
16726                         uint32_t _flags_save_string = ndr->flags;
16727                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16728                         if (r->name_array) {
16729                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16730                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16731                         }
16732                         ndr->flags = _flags_save_string;
16733                 }
16734         }
16735         return NDR_ERR_SUCCESS;
16736 }
16737
16738 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16739 {
16740         uint32_t _ptr_name_array;
16741         TALLOC_CTX *_mem_save_name_array_0;
16742         if (ndr_flags & NDR_SCALARS) {
16743                 NDR_CHECK(ndr_pull_align(ndr, 4));
16744                 {
16745                         uint32_t _flags_save_string = ndr->flags;
16746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16747                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16748                         if (_ptr_name_array) {
16749                                 NDR_PULL_ALLOC(ndr, r->name_array);
16750                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16751                         } else {
16752                                 r->name_array = NULL;
16753                         }
16754                         ndr->flags = _flags_save_string;
16755                 }
16756         }
16757         if (ndr_flags & NDR_BUFFERS) {
16758                 {
16759                         uint32_t _flags_save_string = ndr->flags;
16760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16761                         if (r->name_array) {
16762                                 uint32_t _relative_save_offset;
16763                                 _relative_save_offset = ndr->offset;
16764                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16765                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16766                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16767                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16768                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16769                                 ndr->offset = _relative_save_offset;
16770                         }
16771                         ndr->flags = _flags_save_string;
16772                 }
16773         }
16774         return NDR_ERR_SUCCESS;
16775 }
16776
16777 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16778 {
16779         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16780         ndr->depth++;
16781         ndr_print_ptr(ndr, "name_array", r->name_array);
16782         ndr->depth++;
16783         if (r->name_array) {
16784                 ndr_print_string(ndr, "name_array", r->name_array);
16785         }
16786         ndr->depth--;
16787         ndr->depth--;
16788 }
16789
16790 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16791 {
16792         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16793 }
16794
16795 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16796 {
16797         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16798         if (ndr_flags & NDR_SCALARS) {
16799                 int level = ndr_push_get_switch_value(ndr, r);
16800                 switch (level) {
16801                         case 1: {
16802                                 NDR_CHECK(ndr_push_align(ndr, 4));
16803                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16804                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16805                         break; }
16806
16807                         default: {
16808                         break; }
16809
16810                 }
16811         }
16812         if (ndr_flags & NDR_BUFFERS) {
16813                 int level = ndr_push_get_switch_value(ndr, r);
16814                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16815                 switch (level) {
16816                         case 1:
16817                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16818                         break;
16819
16820                         default:
16821                         break;
16822
16823                 }
16824         }
16825         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16826         return NDR_ERR_SUCCESS;
16827 }
16828
16829 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16830 {
16831         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16832         int level;
16833         level = ndr_pull_get_switch_value(ndr, r);
16834         if (ndr_flags & NDR_SCALARS) {
16835                 switch (level) {
16836                         case 1: {
16837                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16838                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16839                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16840                         break; }
16841
16842                         default: {
16843                         break; }
16844
16845                 }
16846         }
16847         if (ndr_flags & NDR_BUFFERS) {
16848                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16849                 switch (level) {
16850                         case 1:
16851                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16852                         break;
16853
16854                         default:
16855                         break;
16856
16857                 }
16858         }
16859         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16860         return NDR_ERR_SUCCESS;
16861 }
16862
16863 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16864 {
16865         int level;
16866         level = ndr_print_get_switch_value(ndr, r);
16867         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16868         switch (level) {
16869                 case 1:
16870                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16871                 break;
16872
16873                 default:
16874                 break;
16875
16876         }
16877 }
16878
16879 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16880 {
16881         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16882         return NDR_ERR_SUCCESS;
16883 }
16884
16885 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16886 {
16887         uint32_t v;
16888         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16889         *r = v;
16890         return NDR_ERR_SUCCESS;
16891 }
16892
16893 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16894 {
16895         ndr_print_uint32(ndr, name, r);
16896         ndr->depth++;
16897         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16898         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16899         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16900         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16901         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16902         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16903         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16904         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16905         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16906         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16907         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16908         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16909         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16910         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16911         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16912         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16913         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16914         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16915         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16916         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16917         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16918         ndr->depth--;
16919 }
16920
16921 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16922 {
16923         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16924         return NDR_ERR_SUCCESS;
16925 }
16926
16927 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *r)
16928 {
16929         uint16_t v;
16930         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16931         *r = v;
16932         return NDR_ERR_SUCCESS;
16933 }
16934
16935 _PUBLIC_ void ndr_print_spoolss_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16936 {
16937         const char *val = NULL;
16938
16939         switch (r) {
16940                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16941                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16942                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16943                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16944                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16945                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16946                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16947                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16948                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16949                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
16950                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
16951                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
16952                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
16953                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
16954                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
16955                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
16956                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
16957                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
16958                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
16959                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
16960                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
16961                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
16962                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
16963                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
16964                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
16965                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
16966         }
16967         ndr_print_enum(ndr, name, "ENUM", val, r);
16968 }
16969
16970 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
16971 {
16972         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16973         return NDR_ERR_SUCCESS;
16974 }
16975
16976 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
16977 {
16978         uint16_t v;
16979         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16980         *r = v;
16981         return NDR_ERR_SUCCESS;
16982 }
16983
16984 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
16985 {
16986         const char *val = NULL;
16987
16988         switch (r) {
16989                 case SPOOLSS_NOTIFY_PRINTER: val = "SPOOLSS_NOTIFY_PRINTER"; break;
16990                 case SPOOLSS_NOTIFY_JOB: val = "SPOOLSS_NOTIFY_JOB"; break;
16991         }
16992         ndr_print_enum(ndr, name, "ENUM", val, r);
16993 }
16994
16995 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
16996 {
16997         uint32_t cntr_fields_1;
16998         if (ndr_flags & NDR_SCALARS) {
16999                 NDR_CHECK(ndr_push_align(ndr, 4));
17000                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17001                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17002                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17006         }
17007         if (ndr_flags & NDR_BUFFERS) {
17008                 if (r->fields) {
17009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17010                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17011                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
17012                         }
17013                 }
17014         }
17015         return NDR_ERR_SUCCESS;
17016 }
17017
17018 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17019 {
17020         uint32_t _ptr_fields;
17021         uint32_t cntr_fields_1;
17022         TALLOC_CTX *_mem_save_fields_0;
17023         TALLOC_CTX *_mem_save_fields_1;
17024         if (ndr_flags & NDR_SCALARS) {
17025                 NDR_CHECK(ndr_pull_align(ndr, 4));
17026                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17027                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17028                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17030                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17031                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17032                 if (_ptr_fields) {
17033                         NDR_PULL_ALLOC(ndr, r->fields);
17034                 } else {
17035                         r->fields = NULL;
17036                 }
17037         }
17038         if (ndr_flags & NDR_BUFFERS) {
17039                 if (r->fields) {
17040                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17041                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17043                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17044                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17045                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17046                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17047                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17048                         }
17049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17050                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17051                 }
17052                 if (r->fields) {
17053                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17054                 }
17055         }
17056         return NDR_ERR_SUCCESS;
17057 }
17058
17059 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17060 {
17061         uint32_t cntr_fields_1;
17062         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17063         ndr->depth++;
17064         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17065         ndr_print_uint16(ndr, "u1", r->u1);
17066         ndr_print_uint32(ndr, "u2", r->u2);
17067         ndr_print_uint32(ndr, "u3", r->u3);
17068         ndr_print_uint32(ndr, "count", r->count);
17069         ndr_print_ptr(ndr, "fields", r->fields);
17070         ndr->depth++;
17071         if (r->fields) {
17072                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17073                 ndr->depth++;
17074                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17075                         char *idx_1=NULL;
17076                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17077                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
17078                                 free(idx_1);
17079                         }
17080                 }
17081                 ndr->depth--;
17082         }
17083         ndr->depth--;
17084         ndr->depth--;
17085 }
17086
17087 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17088 {
17089         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17090         return NDR_ERR_SUCCESS;
17091 }
17092
17093 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17094 {
17095         uint32_t v;
17096         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17097         *r = v;
17098         return NDR_ERR_SUCCESS;
17099 }
17100
17101 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17102 {
17103         ndr_print_uint32(ndr, name, r);
17104         ndr->depth++;
17105         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17106         ndr->depth--;
17107 }
17108
17109 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17110 {
17111         uint32_t cntr_types_1;
17112         if (ndr_flags & NDR_SCALARS) {
17113                 NDR_CHECK(ndr_push_align(ndr, 4));
17114                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17115                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17118         }
17119         if (ndr_flags & NDR_BUFFERS) {
17120                 if (r->types) {
17121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17122                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17123                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17124                         }
17125                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17126                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17127                         }
17128                 }
17129         }
17130         return NDR_ERR_SUCCESS;
17131 }
17132
17133 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17134 {
17135         uint32_t _ptr_types;
17136         uint32_t cntr_types_1;
17137         TALLOC_CTX *_mem_save_types_0;
17138         TALLOC_CTX *_mem_save_types_1;
17139         if (ndr_flags & NDR_SCALARS) {
17140                 NDR_CHECK(ndr_pull_align(ndr, 4));
17141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17142                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17144                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17145                 if (_ptr_types) {
17146                         NDR_PULL_ALLOC(ndr, r->types);
17147                 } else {
17148                         r->types = NULL;
17149                 }
17150         }
17151         if (ndr_flags & NDR_BUFFERS) {
17152                 if (r->types) {
17153                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17154                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17155                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17156                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17157                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17158                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17159                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17160                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17161                         }
17162                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17163                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17164                         }
17165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17166                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17167                 }
17168                 if (r->types) {
17169                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17170                 }
17171         }
17172         return NDR_ERR_SUCCESS;
17173 }
17174
17175 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17176 {
17177         uint32_t cntr_types_1;
17178         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17179         ndr->depth++;
17180         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17181         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17182         ndr_print_uint32(ndr, "count", r->count);
17183         ndr_print_ptr(ndr, "types", r->types);
17184         ndr->depth++;
17185         if (r->types) {
17186                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17187                 ndr->depth++;
17188                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17189                         char *idx_1=NULL;
17190                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17191                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17192                                 free(idx_1);
17193                         }
17194                 }
17195                 ndr->depth--;
17196         }
17197         ndr->depth--;
17198         ndr->depth--;
17199 }
17200
17201 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17202 {
17203         if (ndr_flags & NDR_SCALARS) {
17204                 NDR_CHECK(ndr_push_align(ndr, 4));
17205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17206                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17207         }
17208         if (ndr_flags & NDR_BUFFERS) {
17209                 if (r->string) {
17210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17211                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17212                 }
17213         }
17214         return NDR_ERR_SUCCESS;
17215 }
17216
17217 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17218 {
17219         uint32_t _ptr_string;
17220         TALLOC_CTX *_mem_save_string_0;
17221         if (ndr_flags & NDR_SCALARS) {
17222                 NDR_CHECK(ndr_pull_align(ndr, 4));
17223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17225                 if (_ptr_string) {
17226                         NDR_PULL_ALLOC(ndr, r->string);
17227                 } else {
17228                         r->string = NULL;
17229                 }
17230         }
17231         if (ndr_flags & NDR_BUFFERS) {
17232                 if (r->string) {
17233                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17234                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17235                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17236                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17237                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17238                 }
17239                 if (r->string) {
17240                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17241                 }
17242         }
17243         return NDR_ERR_SUCCESS;
17244 }
17245
17246 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17247 {
17248         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17249         ndr->depth++;
17250         ndr_print_uint32(ndr, "size", r->size);
17251         ndr_print_ptr(ndr, "string", r->string);
17252         ndr->depth++;
17253         if (r->string) {
17254                 ndr_print_string(ndr, "string", r->string);
17255         }
17256         ndr->depth--;
17257         ndr->depth--;
17258 }
17259
17260 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17261 {
17262         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17263         return NDR_ERR_SUCCESS;
17264 }
17265
17266 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17267 {
17268         uint32_t v;
17269         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17270         *r = v;
17271         return NDR_ERR_SUCCESS;
17272 }
17273
17274 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17275 {
17276         const char *val = NULL;
17277
17278         switch (r) {
17279                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17280                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17281                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17282                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17283                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17284         }
17285         ndr_print_enum(ndr, name, "ENUM", val, r);
17286 }
17287
17288 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17289 {
17290         if (ndr_flags & NDR_SCALARS) {
17291                 int level = ndr_push_get_switch_value(ndr, r);
17292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17293                 switch (level) {
17294                         case 1: {
17295                                 uint32_t cntr_integer_0;
17296                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17297                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17298                                 }
17299                         break; }
17300
17301                         case 2: {
17302                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17303                         break; }
17304
17305                         case 3: {
17306                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17307                         break; }
17308
17309                         case 4: {
17310                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17311                         break; }
17312
17313                         case 5: {
17314                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17315                         break; }
17316
17317                         default:
17318                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17319                 }
17320         }
17321         if (ndr_flags & NDR_BUFFERS) {
17322                 int level = ndr_push_get_switch_value(ndr, r);
17323                 switch (level) {
17324                         case 1:
17325                         break;
17326
17327                         case 2:
17328                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17329                         break;
17330
17331                         case 3:
17332                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17333                         break;
17334
17335                         case 4:
17336                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17337                         break;
17338
17339                         case 5:
17340                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17341                         break;
17342
17343                         default:
17344                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17345                 }
17346         }
17347         return NDR_ERR_SUCCESS;
17348 }
17349
17350 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17351 {
17352         int level;
17353         uint32_t _level;
17354         level = ndr_pull_get_switch_value(ndr, r);
17355         if (ndr_flags & NDR_SCALARS) {
17356                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17357                 if (_level != level) {
17358                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17359                 }
17360                 switch (level) {
17361                         case 1: {
17362                                 uint32_t cntr_integer_0;
17363                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17364                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17365                                 }
17366                         break; }
17367
17368                         case 2: {
17369                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17370                         break; }
17371
17372                         case 3: {
17373                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17374                         break; }
17375
17376                         case 4: {
17377                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17378                         break; }
17379
17380                         case 5: {
17381                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17382                         break; }
17383
17384                         default:
17385                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17386                 }
17387         }
17388         if (ndr_flags & NDR_BUFFERS) {
17389                 switch (level) {
17390                         case 1:
17391                         break;
17392
17393                         case 2:
17394                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17395                         break;
17396
17397                         case 3:
17398                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17399                         break;
17400
17401                         case 4:
17402                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17403                         break;
17404
17405                         case 5:
17406                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17407                         break;
17408
17409                         default:
17410                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17411                 }
17412         }
17413         return NDR_ERR_SUCCESS;
17414 }
17415
17416 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17417 {
17418         int level;
17419         uint32_t cntr_integer_0;
17420         level = ndr_print_get_switch_value(ndr, r);
17421         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17422         switch (level) {
17423                 case 1:
17424                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17425                         ndr->depth++;
17426                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17427                                 char *idx_0=NULL;
17428                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17429                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17430                                         free(idx_0);
17431                                 }
17432                         }
17433                         ndr->depth--;
17434                 break;
17435
17436                 case 2:
17437                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17438                 break;
17439
17440                 case 3:
17441                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17442                 break;
17443
17444                 case 4:
17445                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17446                 break;
17447
17448                 case 5:
17449                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17450                 break;
17451
17452                 default:
17453                         ndr_print_bad_level(ndr, name, level);
17454         }
17455 }
17456
17457 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17458 {
17459         if (ndr_flags & NDR_SCALARS) {
17460                 NDR_CHECK(ndr_push_align(ndr, 4));
17461                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17462                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17463                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17464                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17465                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17466                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17467         }
17468         if (ndr_flags & NDR_BUFFERS) {
17469                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17470         }
17471         return NDR_ERR_SUCCESS;
17472 }
17473
17474 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17475 {
17476         if (ndr_flags & NDR_SCALARS) {
17477                 NDR_CHECK(ndr_pull_align(ndr, 4));
17478                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17479                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17480                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17482                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17483                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17484         }
17485         if (ndr_flags & NDR_BUFFERS) {
17486                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17487         }
17488         return NDR_ERR_SUCCESS;
17489 }
17490
17491 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17492 {
17493         ndr_print_struct(ndr, name, "spoolss_Notify");
17494         ndr->depth++;
17495         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17496         ndr_print_spoolss_Field(ndr, "field", r->field);
17497         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17498         ndr_print_uint32(ndr, "job_id", r->job_id);
17499         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17500         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17501         ndr->depth--;
17502 }
17503
17504 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17505 {
17506         uint32_t cntr_notifies_0;
17507         if (ndr_flags & NDR_SCALARS) {
17508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17509                 NDR_CHECK(ndr_push_align(ndr, 4));
17510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17512                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17513                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17514                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17515                 }
17516         }
17517         if (ndr_flags & NDR_BUFFERS) {
17518                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17519                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17520                 }
17521         }
17522         return NDR_ERR_SUCCESS;
17523 }
17524
17525 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17526 {
17527         uint32_t cntr_notifies_0;
17528         TALLOC_CTX *_mem_save_notifies_0;
17529         if (ndr_flags & NDR_SCALARS) {
17530                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17531                 NDR_CHECK(ndr_pull_align(ndr, 4));
17532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17535                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17536                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17537                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17538                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17539                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17540                 }
17541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17542                 if (r->notifies) {
17543                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17544                 }
17545         }
17546         if (ndr_flags & NDR_BUFFERS) {
17547                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17548                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17549                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17550                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17551                 }
17552                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17553         }
17554         return NDR_ERR_SUCCESS;
17555 }
17556
17557 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17558 {
17559         uint32_t cntr_notifies_0;
17560         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17561         ndr->depth++;
17562         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17563         ndr_print_uint32(ndr, "flags", r->flags);
17564         ndr_print_uint32(ndr, "count", r->count);
17565         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17566         ndr->depth++;
17567         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17568                 char *idx_0=NULL;
17569                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17570                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17571                         free(idx_0);
17572                 }
17573         }
17574         ndr->depth--;
17575         ndr->depth--;
17576 }
17577
17578 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17579 {
17580         if (ndr_flags & NDR_SCALARS) {
17581                 int level = ndr_push_get_switch_value(ndr, r);
17582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17583                 switch (level) {
17584                         case 0: {
17585                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17586                         break; }
17587
17588                         default:
17589                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17590                 }
17591         }
17592         if (ndr_flags & NDR_BUFFERS) {
17593                 int level = ndr_push_get_switch_value(ndr, r);
17594                 switch (level) {
17595                         case 0:
17596                                 if (r->info0) {
17597                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17598                                 }
17599                         break;
17600
17601                         default:
17602                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17603                 }
17604         }
17605         return NDR_ERR_SUCCESS;
17606 }
17607
17608 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17609 {
17610         int level;
17611         uint32_t _level;
17612         TALLOC_CTX *_mem_save_info0_0;
17613         level = ndr_pull_get_switch_value(ndr, r);
17614         if (ndr_flags & NDR_SCALARS) {
17615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17616                 if (_level != level) {
17617                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17618                 }
17619                 switch (level) {
17620                         case 0: {
17621                                 uint32_t _ptr_info0;
17622                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17623                                 if (_ptr_info0) {
17624                                         NDR_PULL_ALLOC(ndr, r->info0);
17625                                 } else {
17626                                         r->info0 = NULL;
17627                                 }
17628                         break; }
17629
17630                         default:
17631                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17632                 }
17633         }
17634         if (ndr_flags & NDR_BUFFERS) {
17635                 switch (level) {
17636                         case 0:
17637                                 if (r->info0) {
17638                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17639                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17640                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17641                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17642                                 }
17643                         break;
17644
17645                         default:
17646                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17647                 }
17648         }
17649         return NDR_ERR_SUCCESS;
17650 }
17651
17652 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17653 {
17654         int level;
17655         level = ndr_print_get_switch_value(ndr, r);
17656         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17657         switch (level) {
17658                 case 0:
17659                         ndr_print_ptr(ndr, "info0", r->info0);
17660                         ndr->depth++;
17661                         if (r->info0) {
17662                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17663                         }
17664                         ndr->depth--;
17665                 break;
17666
17667                 default:
17668                         ndr_print_bad_level(ndr, name, level);
17669         }
17670 }
17671
17672 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17673 {
17674         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17675         return NDR_ERR_SUCCESS;
17676 }
17677
17678 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17679 {
17680         uint32_t v;
17681         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17682         *r = v;
17683         return NDR_ERR_SUCCESS;
17684 }
17685
17686 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17687 {
17688         ndr_print_uint32(ndr, name, r);
17689         ndr->depth++;
17690         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17691         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17692         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17693         ndr->depth--;
17694 }
17695
17696 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17697 {
17698         if (ndr_flags & NDR_SCALARS) {
17699                 NDR_CHECK(ndr_push_align(ndr, 4));
17700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17701                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17704                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17705                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17706                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17707         }
17708         if (ndr_flags & NDR_BUFFERS) {
17709                 if (r->client) {
17710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17714                 }
17715                 if (r->user) {
17716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17720                 }
17721         }
17722         return NDR_ERR_SUCCESS;
17723 }
17724
17725 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17726 {
17727         uint32_t _ptr_client;
17728         TALLOC_CTX *_mem_save_client_0;
17729         uint32_t _ptr_user;
17730         TALLOC_CTX *_mem_save_user_0;
17731         if (ndr_flags & NDR_SCALARS) {
17732                 NDR_CHECK(ndr_pull_align(ndr, 4));
17733                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17734                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17735                 if (_ptr_client) {
17736                         NDR_PULL_ALLOC(ndr, r->client);
17737                 } else {
17738                         r->client = NULL;
17739                 }
17740                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17741                 if (_ptr_user) {
17742                         NDR_PULL_ALLOC(ndr, r->user);
17743                 } else {
17744                         r->user = NULL;
17745                 }
17746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17747                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17748                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17749                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17750         }
17751         if (ndr_flags & NDR_BUFFERS) {
17752                 if (r->client) {
17753                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17754                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17755                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17756                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17757                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17758                                 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));
17759                         }
17760                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17761                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17762                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17763                 }
17764                 if (r->user) {
17765                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17766                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17767                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17768                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17769                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17770                                 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));
17771                         }
17772                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17773                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17774                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17775                 }
17776         }
17777         return NDR_ERR_SUCCESS;
17778 }
17779
17780 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17781 {
17782         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17783         ndr->depth++;
17784         ndr_print_uint32(ndr, "size", r->size);
17785         ndr_print_ptr(ndr, "client", r->client);
17786         ndr->depth++;
17787         if (r->client) {
17788                 ndr_print_string(ndr, "client", r->client);
17789         }
17790         ndr->depth--;
17791         ndr_print_ptr(ndr, "user", r->user);
17792         ndr->depth++;
17793         if (r->user) {
17794                 ndr_print_string(ndr, "user", r->user);
17795         }
17796         ndr->depth--;
17797         ndr_print_uint32(ndr, "build", r->build);
17798         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17799         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17800         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17801         ndr->depth--;
17802 }
17803
17804 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17805 {
17806         if (ndr_flags & NDR_SCALARS) {
17807                 NDR_CHECK(ndr_push_align(ndr, 4));
17808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17809         }
17810         if (ndr_flags & NDR_BUFFERS) {
17811         }
17812         return NDR_ERR_SUCCESS;
17813 }
17814
17815 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17816 {
17817         if (ndr_flags & NDR_SCALARS) {
17818                 NDR_CHECK(ndr_pull_align(ndr, 4));
17819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17820         }
17821         if (ndr_flags & NDR_BUFFERS) {
17822         }
17823         return NDR_ERR_SUCCESS;
17824 }
17825
17826 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17827 {
17828         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17829         ndr->depth++;
17830         ndr_print_uint32(ndr, "not_used", r->not_used);
17831         ndr->depth--;
17832 }
17833
17834 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17835 {
17836         if (ndr_flags & NDR_SCALARS) {
17837                 NDR_CHECK(ndr_push_align(ndr, 4));
17838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17841                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17842                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17844                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17845                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17846                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17847                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17848         }
17849         if (ndr_flags & NDR_BUFFERS) {
17850                 if (r->client) {
17851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17854                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17855                 }
17856                 if (r->user) {
17857                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17859                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17860                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17861                 }
17862         }
17863         return NDR_ERR_SUCCESS;
17864 }
17865
17866 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17867 {
17868         uint32_t _ptr_client;
17869         TALLOC_CTX *_mem_save_client_0;
17870         uint32_t _ptr_user;
17871         TALLOC_CTX *_mem_save_user_0;
17872         if (ndr_flags & NDR_SCALARS) {
17873                 NDR_CHECK(ndr_pull_align(ndr, 4));
17874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17877                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17878                 if (_ptr_client) {
17879                         NDR_PULL_ALLOC(ndr, r->client);
17880                 } else {
17881                         r->client = NULL;
17882                 }
17883                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17884                 if (_ptr_user) {
17885                         NDR_PULL_ALLOC(ndr, r->user);
17886                 } else {
17887                         r->user = NULL;
17888                 }
17889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17890                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17891                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17892                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17893                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17894         }
17895         if (ndr_flags & NDR_BUFFERS) {
17896                 if (r->client) {
17897                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17898                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17899                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17900                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17901                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17902                                 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));
17903                         }
17904                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17905                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17907                 }
17908                 if (r->user) {
17909                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17910                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17911                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17912                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17913                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17914                                 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));
17915                         }
17916                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17917                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17919                 }
17920         }
17921         return NDR_ERR_SUCCESS;
17922 }
17923
17924 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17925 {
17926         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17927         ndr->depth++;
17928         ndr_print_uint32(ndr, "size", r->size);
17929         ndr_print_uint32(ndr, "flags", r->flags);
17930         ndr_print_uint32(ndr, "size2", r->size2);
17931         ndr_print_ptr(ndr, "client", r->client);
17932         ndr->depth++;
17933         if (r->client) {
17934                 ndr_print_string(ndr, "client", r->client);
17935         }
17936         ndr->depth--;
17937         ndr_print_ptr(ndr, "user", r->user);
17938         ndr->depth++;
17939         if (r->user) {
17940                 ndr_print_string(ndr, "user", r->user);
17941         }
17942         ndr->depth--;
17943         ndr_print_uint32(ndr, "build", r->build);
17944         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17945         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17946         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17947         ndr_print_udlong(ndr, "reserved", r->reserved);
17948         ndr->depth--;
17949 }
17950
17951 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
17952 {
17953         if (ndr_flags & NDR_SCALARS) {
17954                 int level = ndr_push_get_switch_value(ndr, r);
17955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17956                 switch (level) {
17957                         case 1: {
17958                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
17959                         break; }
17960
17961                         case 2: {
17962                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
17963                         break; }
17964
17965                         case 3: {
17966                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
17967                         break; }
17968
17969                         default:
17970                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17971                 }
17972         }
17973         if (ndr_flags & NDR_BUFFERS) {
17974                 int level = ndr_push_get_switch_value(ndr, r);
17975                 switch (level) {
17976                         case 1:
17977                                 if (r->level1) {
17978                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
17979                                 }
17980                         break;
17981
17982                         case 2:
17983                                 if (r->level2) {
17984                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
17985                                 }
17986                         break;
17987
17988                         case 3:
17989                                 if (r->level3) {
17990                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
17991                                 }
17992                         break;
17993
17994                         default:
17995                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17996                 }
17997         }
17998         return NDR_ERR_SUCCESS;
17999 }
18000
18001 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18002 {
18003         int level;
18004         uint32_t _level;
18005         TALLOC_CTX *_mem_save_level1_0;
18006         TALLOC_CTX *_mem_save_level2_0;
18007         TALLOC_CTX *_mem_save_level3_0;
18008         level = ndr_pull_get_switch_value(ndr, r);
18009         if (ndr_flags & NDR_SCALARS) {
18010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18011                 if (_level != level) {
18012                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18013                 }
18014                 switch (level) {
18015                         case 1: {
18016                                 uint32_t _ptr_level1;
18017                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18018                                 if (_ptr_level1) {
18019                                         NDR_PULL_ALLOC(ndr, r->level1);
18020                                 } else {
18021                                         r->level1 = NULL;
18022                                 }
18023                         break; }
18024
18025                         case 2: {
18026                                 uint32_t _ptr_level2;
18027                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18028                                 if (_ptr_level2) {
18029                                         NDR_PULL_ALLOC(ndr, r->level2);
18030                                 } else {
18031                                         r->level2 = NULL;
18032                                 }
18033                         break; }
18034
18035                         case 3: {
18036                                 uint32_t _ptr_level3;
18037                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18038                                 if (_ptr_level3) {
18039                                         NDR_PULL_ALLOC(ndr, r->level3);
18040                                 } else {
18041                                         r->level3 = NULL;
18042                                 }
18043                         break; }
18044
18045                         default:
18046                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18047                 }
18048         }
18049         if (ndr_flags & NDR_BUFFERS) {
18050                 switch (level) {
18051                         case 1:
18052                                 if (r->level1) {
18053                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18054                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18055                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18056                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18057                                 }
18058                         break;
18059
18060                         case 2:
18061                                 if (r->level2) {
18062                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18063                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18064                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18065                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18066                                 }
18067                         break;
18068
18069                         case 3:
18070                                 if (r->level3) {
18071                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18072                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18073                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18074                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18075                                 }
18076                         break;
18077
18078                         default:
18079                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18080                 }
18081         }
18082         return NDR_ERR_SUCCESS;
18083 }
18084
18085 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18086 {
18087         int level;
18088         level = ndr_print_get_switch_value(ndr, r);
18089         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18090         switch (level) {
18091                 case 1:
18092                         ndr_print_ptr(ndr, "level1", r->level1);
18093                         ndr->depth++;
18094                         if (r->level1) {
18095                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18096                         }
18097                         ndr->depth--;
18098                 break;
18099
18100                 case 2:
18101                         ndr_print_ptr(ndr, "level2", r->level2);
18102                         ndr->depth++;
18103                         if (r->level2) {
18104                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18105                         }
18106                         ndr->depth--;
18107                 break;
18108
18109                 case 3:
18110                         ndr_print_ptr(ndr, "level3", r->level3);
18111                         ndr->depth++;
18112                         if (r->level3) {
18113                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18114                         }
18115                         ndr->depth--;
18116                 break;
18117
18118                 default:
18119                         ndr_print_bad_level(ndr, name, level);
18120         }
18121 }
18122
18123 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18124 {
18125         if (ndr_flags & NDR_SCALARS) {
18126                 NDR_CHECK(ndr_push_align(ndr, 4));
18127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18128                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18129                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18130         }
18131         if (ndr_flags & NDR_BUFFERS) {
18132                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18133         }
18134         return NDR_ERR_SUCCESS;
18135 }
18136
18137 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18138 {
18139         if (ndr_flags & NDR_SCALARS) {
18140                 NDR_CHECK(ndr_pull_align(ndr, 4));
18141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18142                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18143                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18144         }
18145         if (ndr_flags & NDR_BUFFERS) {
18146                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18147         }
18148         return NDR_ERR_SUCCESS;
18149 }
18150
18151 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18152 {
18153         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18154         ndr->depth++;
18155         ndr_print_uint32(ndr, "level", r->level);
18156         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18157         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18158         ndr->depth--;
18159 }
18160
18161 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18162 {
18163         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18164         return NDR_ERR_SUCCESS;
18165 }
18166
18167 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18168 {
18169         uint32_t v;
18170         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18171         *r = v;
18172         return NDR_ERR_SUCCESS;
18173 }
18174
18175 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18176 {
18177         ndr_print_uint32(ndr, name, r);
18178         ndr->depth++;
18179         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18180         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18181         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18182         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18183         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18184         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18185         ndr->depth--;
18186 }
18187
18188 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18189 {
18190         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18191         return NDR_ERR_SUCCESS;
18192 }
18193
18194 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18195 {
18196         uint32_t v;
18197         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18198         *r = v;
18199         return NDR_ERR_SUCCESS;
18200 }
18201
18202 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18203 {
18204         ndr_print_uint32(ndr, name, r);
18205         ndr->depth++;
18206         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18207         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18208         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18209         ndr->depth--;
18210 }
18211
18212 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18213 {
18214         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18215         return NDR_ERR_SUCCESS;
18216 }
18217
18218 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18219 {
18220         uint32_t v;
18221         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18222         *r = v;
18223         return NDR_ERR_SUCCESS;
18224 }
18225
18226 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18227 {
18228         const char *val = NULL;
18229
18230         switch (r) {
18231                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18232                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18233         }
18234         ndr_print_enum(ndr, name, "ENUM", val, r);
18235 }
18236
18237 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18238 {
18239         if (ndr_flags & NDR_SCALARS) {
18240                 NDR_CHECK(ndr_push_align(ndr, 4));
18241                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18243                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18246                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18247                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18249                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18250                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18251                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18252                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18254                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18255                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18256         }
18257         if (ndr_flags & NDR_BUFFERS) {
18258         }
18259         return NDR_ERR_SUCCESS;
18260 }
18261
18262 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18263 {
18264         if (ndr_flags & NDR_SCALARS) {
18265                 NDR_CHECK(ndr_pull_align(ndr, 4));
18266                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18268                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18271                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18272                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18274                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18275                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18276                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18277                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18279                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18281         }
18282         if (ndr_flags & NDR_BUFFERS) {
18283         }
18284         return NDR_ERR_SUCCESS;
18285 }
18286
18287 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18288 {
18289         ndr_print_struct(ndr, name, "spoolss_PortData1");
18290         ndr->depth++;
18291         ndr_print_string(ndr, "portname", r->portname);
18292         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18293         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18294         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18295         ndr_print_uint32(ndr, "reserved", r->reserved);
18296         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18297         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18298         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18299         ndr_print_string(ndr, "queue", r->queue);
18300         ndr_print_string(ndr, "ip_address", r->ip_address);
18301         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18302         ndr_print_string(ndr, "device_type", r->device_type);
18303         ndr_print_uint32(ndr, "port_number", r->port_number);
18304         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18305         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18306         ndr->depth--;
18307 }
18308
18309 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18310 {
18311         if (ndr_flags & NDR_SCALARS) {
18312                 NDR_CHECK(ndr_push_align(ndr, 4));
18313                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18315                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18318                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18319                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18321                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18322                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18326                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18327         }
18328         if (ndr_flags & NDR_BUFFERS) {
18329         }
18330         return NDR_ERR_SUCCESS;
18331 }
18332
18333 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18334 {
18335         if (ndr_flags & NDR_SCALARS) {
18336                 NDR_CHECK(ndr_pull_align(ndr, 4));
18337                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18339                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18340                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18341                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18342                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18343                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18345                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18346                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18348                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18351         }
18352         if (ndr_flags & NDR_BUFFERS) {
18353         }
18354         return NDR_ERR_SUCCESS;
18355 }
18356
18357 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18358 {
18359         ndr_print_struct(ndr, name, "spoolss_PortData2");
18360         ndr->depth++;
18361         ndr_print_string(ndr, "portname", r->portname);
18362         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18363         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18364         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18365         ndr_print_uint32(ndr, "reserved", r->reserved);
18366         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18367         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18368         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18369         ndr_print_string(ndr, "queue", r->queue);
18370         ndr_print_string(ndr, "device_type", r->device_type);
18371         ndr_print_uint32(ndr, "port_number", r->port_number);
18372         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18373         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18374         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18375         ndr->depth--;
18376 }
18377
18378 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18379 {
18380         if (ndr_flags & NDR_SCALARS) {
18381                 NDR_CHECK(ndr_push_align(ndr, 4));
18382                 {
18383                         uint32_t _flags_save_string = ndr->flags;
18384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18385                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18386                         ndr->flags = _flags_save_string;
18387                 }
18388         }
18389         if (ndr_flags & NDR_BUFFERS) {
18390         }
18391         return NDR_ERR_SUCCESS;
18392 }
18393
18394 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18395 {
18396         if (ndr_flags & NDR_SCALARS) {
18397                 NDR_CHECK(ndr_pull_align(ndr, 4));
18398                 {
18399                         uint32_t _flags_save_string = ndr->flags;
18400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18401                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18402                         ndr->flags = _flags_save_string;
18403                 }
18404         }
18405         if (ndr_flags & NDR_BUFFERS) {
18406         }
18407         return NDR_ERR_SUCCESS;
18408 }
18409
18410 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18411 {
18412         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18413         ndr->depth++;
18414         ndr_print_string(ndr, "dll_name", r->dll_name);
18415         ndr->depth--;
18416 }
18417
18418 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18419 {
18420         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18421         return NDR_ERR_SUCCESS;
18422 }
18423
18424 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18425 {
18426         uint32_t v;
18427         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18428         *r = v;
18429         return NDR_ERR_SUCCESS;
18430 }
18431
18432 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18433 {
18434         ndr_print_uint32(ndr, name, r);
18435         ndr->depth++;
18436         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18437         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18438         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18439         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18440         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18441         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18442         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18443         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18444         ndr->depth--;
18445 }
18446
18447 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18448 {
18449         if (flags & NDR_IN) {
18450                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18451                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18452                 if (r->in.server) {
18453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18456                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18457                 }
18458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18459                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18460                 if (r->in.buffer) {
18461                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18462                 }
18463                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18464         }
18465         if (flags & NDR_OUT) {
18466                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18467                 if (r->out.info) {
18468                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18469                 }
18470                 if (r->out.needed == NULL) {
18471                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18472                 }
18473                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18474                 if (r->out.count == NULL) {
18475                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18476                 }
18477                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18478                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18479         }
18480         return NDR_ERR_SUCCESS;
18481 }
18482
18483 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18484 {
18485         uint32_t _ptr_server;
18486         uint32_t _ptr_buffer;
18487         uint32_t _ptr_info;
18488         TALLOC_CTX *_mem_save_server_0;
18489         TALLOC_CTX *_mem_save_buffer_0;
18490         TALLOC_CTX *_mem_save_info_0;
18491         TALLOC_CTX *_mem_save_needed_0;
18492         TALLOC_CTX *_mem_save_count_0;
18493         if (flags & NDR_IN) {
18494                 ZERO_STRUCT(r->out);
18495
18496                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18497                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18498                 if (_ptr_server) {
18499                         NDR_PULL_ALLOC(ndr, r->in.server);
18500                 } else {
18501                         r->in.server = NULL;
18502                 }
18503                 if (r->in.server) {
18504                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18505                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18506                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18507                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18508                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18509                                 return 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));
18510                         }
18511                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18512                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18514                 }
18515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18516                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18517                 if (_ptr_buffer) {
18518                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18519                 } else {
18520                         r->in.buffer = NULL;
18521                 }
18522                 if (r->in.buffer) {
18523                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18524                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18525                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18526                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18527                 }
18528                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18529                 NDR_PULL_ALLOC(ndr, r->out.needed);
18530                 ZERO_STRUCTP(r->out.needed);
18531                 NDR_PULL_ALLOC(ndr, r->out.count);
18532                 ZERO_STRUCTP(r->out.count);
18533         }
18534         if (flags & NDR_OUT) {
18535                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18536                 if (_ptr_info) {
18537                         NDR_PULL_ALLOC(ndr, r->out.info);
18538                 } else {
18539                         r->out.info = NULL;
18540                 }
18541                 if (r->out.info) {
18542                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18543                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18544                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18545                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18546                 }
18547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18548                         NDR_PULL_ALLOC(ndr, r->out.needed);
18549                 }
18550                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18551                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18555                         NDR_PULL_ALLOC(ndr, r->out.count);
18556                 }
18557                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18558                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18562         }
18563         return NDR_ERR_SUCCESS;
18564 }
18565
18566 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18567 {
18568         uint32_t cntr_info_0;
18569         if (flags & NDR_IN) {
18570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18572         }
18573         if (flags & NDR_OUT) {
18574                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18575                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18576                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18577                 }
18578                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18579                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18580                 }
18581         }
18582         return NDR_ERR_SUCCESS;
18583 }
18584
18585 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18586 {
18587         uint32_t cntr_info_0;
18588         TALLOC_CTX *_mem_save_info_0;
18589         if (flags & NDR_IN) {
18590                 ZERO_STRUCT(r->out);
18591
18592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18594         }
18595         if (flags & NDR_OUT) {
18596                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18597                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18598                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18599                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18600                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18601                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18602                 }
18603                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18604                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18605                 }
18606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18607         }
18608         return NDR_ERR_SUCCESS;
18609 }
18610
18611 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18612 {
18613         uint32_t cntr_info_2;
18614         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18615         ndr->depth++;
18616         if (flags & NDR_SET_VALUES) {
18617                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18618         }
18619         if (flags & NDR_IN) {
18620                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18621                 ndr->depth++;
18622                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18623                 ndr_print_ptr(ndr, "server", r->in.server);
18624                 ndr->depth++;
18625                 if (r->in.server) {
18626                         ndr_print_string(ndr, "server", r->in.server);
18627                 }
18628                 ndr->depth--;
18629                 ndr_print_uint32(ndr, "level", r->in.level);
18630                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18631                 ndr->depth++;
18632                 if (r->in.buffer) {
18633                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18634                 }
18635                 ndr->depth--;
18636                 ndr_print_uint32(ndr, "offered", r->in.offered);
18637                 ndr->depth--;
18638         }
18639         if (flags & NDR_OUT) {
18640                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18641                 ndr->depth++;
18642                 ndr_print_ptr(ndr, "count", r->out.count);
18643                 ndr->depth++;
18644                 ndr_print_uint32(ndr, "count", *r->out.count);
18645                 ndr->depth--;
18646                 ndr_print_ptr(ndr, "info", r->out.info);
18647                 ndr->depth++;
18648                 ndr_print_ptr(ndr, "info", *r->out.info);
18649                 ndr->depth++;
18650                 if (*r->out.info) {
18651                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18652                         ndr->depth++;
18653                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18654                                 char *idx_2=NULL;
18655                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18656                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18657                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18658                                         free(idx_2);
18659                                 }
18660                         }
18661                         ndr->depth--;
18662                 }
18663                 ndr->depth--;
18664                 ndr->depth--;
18665                 ndr_print_ptr(ndr, "needed", r->out.needed);
18666                 ndr->depth++;
18667                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18668                 ndr->depth--;
18669                 ndr_print_WERROR(ndr, "result", r->out.result);
18670                 ndr->depth--;
18671         }
18672         ndr->depth--;
18673 }
18674
18675 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18676 {
18677         if (flags & NDR_IN) {
18678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18679                 if (r->in.printername) {
18680                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18681                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18682                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18683                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18684                 }
18685                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18686                 if (r->in.datatype) {
18687                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18688                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18689                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18690                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18691                 }
18692                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18693                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18694         }
18695         if (flags & NDR_OUT) {
18696                 if (r->out.handle == NULL) {
18697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18698                 }
18699                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18700                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18701         }
18702         return NDR_ERR_SUCCESS;
18703 }
18704
18705 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18706 {
18707         uint32_t _ptr_printername;
18708         uint32_t _ptr_datatype;
18709         TALLOC_CTX *_mem_save_printername_0;
18710         TALLOC_CTX *_mem_save_datatype_0;
18711         TALLOC_CTX *_mem_save_handle_0;
18712         if (flags & NDR_IN) {
18713                 ZERO_STRUCT(r->out);
18714
18715                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18716                 if (_ptr_printername) {
18717                         NDR_PULL_ALLOC(ndr, r->in.printername);
18718                 } else {
18719                         r->in.printername = NULL;
18720                 }
18721                 if (r->in.printername) {
18722                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18723                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18724                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18725                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18726                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18727                                 return 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));
18728                         }
18729                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18730                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18731                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18732                 }
18733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18734                 if (_ptr_datatype) {
18735                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18736                 } else {
18737                         r->in.datatype = NULL;
18738                 }
18739                 if (r->in.datatype) {
18740                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18741                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18742                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18743                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18744                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18745                                 return 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));
18746                         }
18747                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18748                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18749                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18750                 }
18751                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18752                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18753                 NDR_PULL_ALLOC(ndr, r->out.handle);
18754                 ZERO_STRUCTP(r->out.handle);
18755         }
18756         if (flags & NDR_OUT) {
18757                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18758                         NDR_PULL_ALLOC(ndr, r->out.handle);
18759                 }
18760                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18761                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18762                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18763                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18764                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18765         }
18766         return NDR_ERR_SUCCESS;
18767 }
18768
18769 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18770 {
18771         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18772         ndr->depth++;
18773         if (flags & NDR_SET_VALUES) {
18774                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18775         }
18776         if (flags & NDR_IN) {
18777                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18778                 ndr->depth++;
18779                 ndr_print_ptr(ndr, "printername", r->in.printername);
18780                 ndr->depth++;
18781                 if (r->in.printername) {
18782                         ndr_print_string(ndr, "printername", r->in.printername);
18783                 }
18784                 ndr->depth--;
18785                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18786                 ndr->depth++;
18787                 if (r->in.datatype) {
18788                         ndr_print_string(ndr, "datatype", r->in.datatype);
18789                 }
18790                 ndr->depth--;
18791                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18792                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18793                 ndr->depth--;
18794         }
18795         if (flags & NDR_OUT) {
18796                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18797                 ndr->depth++;
18798                 ndr_print_ptr(ndr, "handle", r->out.handle);
18799                 ndr->depth++;
18800                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18801                 ndr->depth--;
18802                 ndr_print_WERROR(ndr, "result", r->out.result);
18803                 ndr->depth--;
18804         }
18805         ndr->depth--;
18806 }
18807
18808 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18809 {
18810         if (flags & NDR_IN) {
18811                 if (r->in.handle == NULL) {
18812                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18813                 }
18814                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18816                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
18817                 if (r->in.ctr) {
18818                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18819                 }
18820                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
18821         }
18822         if (flags & NDR_OUT) {
18823                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18824         }
18825         return NDR_ERR_SUCCESS;
18826 }
18827
18828 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
18829 {
18830         uint32_t _ptr_ctr;
18831         TALLOC_CTX *_mem_save_handle_0;
18832         TALLOC_CTX *_mem_save_ctr_0;
18833         if (flags & NDR_IN) {
18834                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18835                         NDR_PULL_ALLOC(ndr, r->in.handle);
18836                 }
18837                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18838                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18839                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18840                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
18843                 if (_ptr_ctr) {
18844                         NDR_PULL_ALLOC(ndr, r->in.ctr);
18845                 } else {
18846                         r->in.ctr = NULL;
18847                 }
18848                 if (r->in.ctr) {
18849                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18850                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
18851                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18852                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
18853                 }
18854                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
18855         }
18856         if (flags & NDR_OUT) {
18857                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18858         }
18859         return NDR_ERR_SUCCESS;
18860 }
18861
18862 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
18863 {
18864         ndr_print_struct(ndr, name, "spoolss_SetJob");
18865         ndr->depth++;
18866         if (flags & NDR_SET_VALUES) {
18867                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18868         }
18869         if (flags & NDR_IN) {
18870                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
18871                 ndr->depth++;
18872                 ndr_print_ptr(ndr, "handle", r->in.handle);
18873                 ndr->depth++;
18874                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18875                 ndr->depth--;
18876                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18877                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
18878                 ndr->depth++;
18879                 if (r->in.ctr) {
18880                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
18881                 }
18882                 ndr->depth--;
18883                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
18884                 ndr->depth--;
18885         }
18886         if (flags & NDR_OUT) {
18887                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
18888                 ndr->depth++;
18889                 ndr_print_WERROR(ndr, "result", r->out.result);
18890                 ndr->depth--;
18891         }
18892         ndr->depth--;
18893 }
18894
18895 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
18896 {
18897         if (flags & NDR_IN) {
18898                 if (r->in.handle == NULL) {
18899                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18900                 }
18901                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18905                 if (r->in.buffer) {
18906                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18907                 }
18908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18909         }
18910         if (flags & NDR_OUT) {
18911                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18912                 if (r->out.info) {
18913                         {
18914                                 struct ndr_push *_ndr_info;
18915                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18916                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18917                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18918                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18919                         }
18920                 }
18921                 if (r->out.needed == NULL) {
18922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18923                 }
18924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18926         }
18927         return NDR_ERR_SUCCESS;
18928 }
18929
18930 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
18931 {
18932         uint32_t _ptr_buffer;
18933         uint32_t _ptr_info;
18934         TALLOC_CTX *_mem_save_handle_0;
18935         TALLOC_CTX *_mem_save_buffer_0;
18936         TALLOC_CTX *_mem_save_info_0;
18937         TALLOC_CTX *_mem_save_needed_0;
18938         if (flags & NDR_IN) {
18939                 ZERO_STRUCT(r->out);
18940
18941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18942                         NDR_PULL_ALLOC(ndr, r->in.handle);
18943                 }
18944                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18945                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18946                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18949                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18950                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18951                 if (_ptr_buffer) {
18952                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18953                 } else {
18954                         r->in.buffer = NULL;
18955                 }
18956                 if (r->in.buffer) {
18957                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18958                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18959                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18960                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18961                 }
18962                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18963                 NDR_PULL_ALLOC(ndr, r->out.needed);
18964                 ZERO_STRUCTP(r->out.needed);
18965         }
18966         if (flags & NDR_OUT) {
18967                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18968                 if (_ptr_info) {
18969                         NDR_PULL_ALLOC(ndr, r->out.info);
18970                 } else {
18971                         r->out.info = NULL;
18972                 }
18973                 if (r->out.info) {
18974                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18975                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18976                         {
18977                                 struct ndr_pull *_ndr_info;
18978                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18979                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
18980                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18981                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18982                         }
18983                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18984                 }
18985                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18986                         NDR_PULL_ALLOC(ndr, r->out.needed);
18987                 }
18988                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18989                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18990                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18991                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18992                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18993         }
18994         return NDR_ERR_SUCCESS;
18995 }
18996
18997 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
18998 {
18999         ndr_print_struct(ndr, name, "spoolss_GetJob");
19000         ndr->depth++;
19001         if (flags & NDR_SET_VALUES) {
19002                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19003         }
19004         if (flags & NDR_IN) {
19005                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19006                 ndr->depth++;
19007                 ndr_print_ptr(ndr, "handle", r->in.handle);
19008                 ndr->depth++;
19009                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19010                 ndr->depth--;
19011                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19012                 ndr_print_uint32(ndr, "level", r->in.level);
19013                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19014                 ndr->depth++;
19015                 if (r->in.buffer) {
19016                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19017                 }
19018                 ndr->depth--;
19019                 ndr_print_uint32(ndr, "offered", r->in.offered);
19020                 ndr->depth--;
19021         }
19022         if (flags & NDR_OUT) {
19023                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19024                 ndr->depth++;
19025                 ndr_print_ptr(ndr, "info", r->out.info);
19026                 ndr->depth++;
19027                 if (r->out.info) {
19028                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19029                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19030                 }
19031                 ndr->depth--;
19032                 ndr_print_ptr(ndr, "needed", r->out.needed);
19033                 ndr->depth++;
19034                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19035                 ndr->depth--;
19036                 ndr_print_WERROR(ndr, "result", r->out.result);
19037                 ndr->depth--;
19038         }
19039         ndr->depth--;
19040 }
19041
19042 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19043 {
19044         if (flags & NDR_IN) {
19045                 if (r->in.handle == NULL) {
19046                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19047                 }
19048                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19053                 if (r->in.buffer) {
19054                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19055                 }
19056                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19057         }
19058         if (flags & NDR_OUT) {
19059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19060                 if (r->out.info) {
19061                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19062                 }
19063                 if (r->out.needed == NULL) {
19064                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19065                 }
19066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19067                 if (r->out.count == NULL) {
19068                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19069                 }
19070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19071                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19072         }
19073         return NDR_ERR_SUCCESS;
19074 }
19075
19076 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19077 {
19078         uint32_t _ptr_buffer;
19079         uint32_t _ptr_info;
19080         TALLOC_CTX *_mem_save_handle_0;
19081         TALLOC_CTX *_mem_save_buffer_0;
19082         TALLOC_CTX *_mem_save_info_0;
19083         TALLOC_CTX *_mem_save_needed_0;
19084         TALLOC_CTX *_mem_save_count_0;
19085         if (flags & NDR_IN) {
19086                 ZERO_STRUCT(r->out);
19087
19088                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19089                         NDR_PULL_ALLOC(ndr, r->in.handle);
19090                 }
19091                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19092                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19093                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19094                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19096                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19097                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19098                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19099                 if (_ptr_buffer) {
19100                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19101                 } else {
19102                         r->in.buffer = NULL;
19103                 }
19104                 if (r->in.buffer) {
19105                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19106                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19107                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19108                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19109                 }
19110                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19111                 NDR_PULL_ALLOC(ndr, r->out.needed);
19112                 ZERO_STRUCTP(r->out.needed);
19113                 NDR_PULL_ALLOC(ndr, r->out.count);
19114                 ZERO_STRUCTP(r->out.count);
19115         }
19116         if (flags & NDR_OUT) {
19117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19118                 if (_ptr_info) {
19119                         NDR_PULL_ALLOC(ndr, r->out.info);
19120                 } else {
19121                         r->out.info = NULL;
19122                 }
19123                 if (r->out.info) {
19124                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19125                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19126                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19127                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19128                 }
19129                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19130                         NDR_PULL_ALLOC(ndr, r->out.needed);
19131                 }
19132                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19133                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19136                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19137                         NDR_PULL_ALLOC(ndr, r->out.count);
19138                 }
19139                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19140                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19144         }
19145         return NDR_ERR_SUCCESS;
19146 }
19147
19148 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19149 {
19150         uint32_t cntr_info_0;
19151         if (flags & NDR_IN) {
19152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19153                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19154         }
19155         if (flags & NDR_OUT) {
19156                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19157                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19158                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19159                 }
19160                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19161                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19162                 }
19163         }
19164         return NDR_ERR_SUCCESS;
19165 }
19166
19167 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19168 {
19169         uint32_t cntr_info_0;
19170         TALLOC_CTX *_mem_save_info_0;
19171         if (flags & NDR_IN) {
19172                 ZERO_STRUCT(r->out);
19173
19174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19175                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19176         }
19177         if (flags & NDR_OUT) {
19178                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19179                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19180                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19181                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19182                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19183                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19184                 }
19185                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19186                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19187                 }
19188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19189         }
19190         return NDR_ERR_SUCCESS;
19191 }
19192
19193 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19194 {
19195         uint32_t cntr_info_2;
19196         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19197         ndr->depth++;
19198         if (flags & NDR_SET_VALUES) {
19199                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19200         }
19201         if (flags & NDR_IN) {
19202                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19203                 ndr->depth++;
19204                 ndr_print_ptr(ndr, "handle", r->in.handle);
19205                 ndr->depth++;
19206                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19207                 ndr->depth--;
19208                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19209                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19210                 ndr_print_uint32(ndr, "level", r->in.level);
19211                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19212                 ndr->depth++;
19213                 if (r->in.buffer) {
19214                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19215                 }
19216                 ndr->depth--;
19217                 ndr_print_uint32(ndr, "offered", r->in.offered);
19218                 ndr->depth--;
19219         }
19220         if (flags & NDR_OUT) {
19221                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19222                 ndr->depth++;
19223                 ndr_print_ptr(ndr, "count", r->out.count);
19224                 ndr->depth++;
19225                 ndr_print_uint32(ndr, "count", *r->out.count);
19226                 ndr->depth--;
19227                 ndr_print_ptr(ndr, "info", r->out.info);
19228                 ndr->depth++;
19229                 ndr_print_ptr(ndr, "info", *r->out.info);
19230                 ndr->depth++;
19231                 if (*r->out.info) {
19232                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19233                         ndr->depth++;
19234                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19235                                 char *idx_2=NULL;
19236                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19237                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19238                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19239                                         free(idx_2);
19240                                 }
19241                         }
19242                         ndr->depth--;
19243                 }
19244                 ndr->depth--;
19245                 ndr->depth--;
19246                 ndr_print_ptr(ndr, "needed", r->out.needed);
19247                 ndr->depth++;
19248                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19249                 ndr->depth--;
19250                 ndr_print_WERROR(ndr, "result", r->out.result);
19251                 ndr->depth--;
19252         }
19253         ndr->depth--;
19254 }
19255
19256 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19257 {
19258         if (flags & NDR_IN) {
19259         }
19260         if (flags & NDR_OUT) {
19261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19262         }
19263         return NDR_ERR_SUCCESS;
19264 }
19265
19266 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19267 {
19268         if (flags & NDR_IN) {
19269         }
19270         if (flags & NDR_OUT) {
19271                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19272         }
19273         return NDR_ERR_SUCCESS;
19274 }
19275
19276 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19277 {
19278         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19279         ndr->depth++;
19280         if (flags & NDR_SET_VALUES) {
19281                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19282         }
19283         if (flags & NDR_IN) {
19284                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19285                 ndr->depth++;
19286                 ndr->depth--;
19287         }
19288         if (flags & NDR_OUT) {
19289                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19290                 ndr->depth++;
19291                 ndr_print_WERROR(ndr, "result", r->out.result);
19292                 ndr->depth--;
19293         }
19294         ndr->depth--;
19295 }
19296
19297 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19298 {
19299         if (flags & NDR_IN) {
19300                 if (r->in.handle == NULL) {
19301                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19302                 }
19303                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19304         }
19305         if (flags & NDR_OUT) {
19306                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19307         }
19308         return NDR_ERR_SUCCESS;
19309 }
19310
19311 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19312 {
19313         TALLOC_CTX *_mem_save_handle_0;
19314         if (flags & NDR_IN) {
19315                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19316                         NDR_PULL_ALLOC(ndr, r->in.handle);
19317                 }
19318                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19319                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19320                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19321                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19322         }
19323         if (flags & NDR_OUT) {
19324                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19325         }
19326         return NDR_ERR_SUCCESS;
19327 }
19328
19329 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19330 {
19331         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19332         ndr->depth++;
19333         if (flags & NDR_SET_VALUES) {
19334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19335         }
19336         if (flags & NDR_IN) {
19337                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19338                 ndr->depth++;
19339                 ndr_print_ptr(ndr, "handle", r->in.handle);
19340                 ndr->depth++;
19341                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19342                 ndr->depth--;
19343                 ndr->depth--;
19344         }
19345         if (flags & NDR_OUT) {
19346                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19347                 ndr->depth++;
19348                 ndr_print_WERROR(ndr, "result", r->out.result);
19349                 ndr->depth--;
19350         }
19351         ndr->depth--;
19352 }
19353
19354 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19355 {
19356         if (flags & NDR_IN) {
19357                 if (r->in.handle == NULL) {
19358                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19359                 }
19360                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19361                 if (r->in.info_ctr == NULL) {
19362                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19363                 }
19364                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19365                 if (r->in.devmode_ctr == NULL) {
19366                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19367                 }
19368                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19369                 if (r->in.secdesc_ctr == NULL) {
19370                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19371                 }
19372                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19373                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19374         }
19375         if (flags & NDR_OUT) {
19376                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19377         }
19378         return NDR_ERR_SUCCESS;
19379 }
19380
19381 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19382 {
19383         TALLOC_CTX *_mem_save_handle_0;
19384         TALLOC_CTX *_mem_save_info_ctr_0;
19385         TALLOC_CTX *_mem_save_devmode_ctr_0;
19386         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19387         if (flags & NDR_IN) {
19388                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19389                         NDR_PULL_ALLOC(ndr, r->in.handle);
19390                 }
19391                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19392                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19393                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19394                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19395                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19396                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19397                 }
19398                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19399                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19400                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19402                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19403                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19404                 }
19405                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19406                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19407                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19408                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19409                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19410                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19411                 }
19412                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19413                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19414                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19415                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19416                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19417         }
19418         if (flags & NDR_OUT) {
19419                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19420         }
19421         return NDR_ERR_SUCCESS;
19422 }
19423
19424 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19425 {
19426         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19427         ndr->depth++;
19428         if (flags & NDR_SET_VALUES) {
19429                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19430         }
19431         if (flags & NDR_IN) {
19432                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19433                 ndr->depth++;
19434                 ndr_print_ptr(ndr, "handle", r->in.handle);
19435                 ndr->depth++;
19436                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19437                 ndr->depth--;
19438                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19439                 ndr->depth++;
19440                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19441                 ndr->depth--;
19442                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19443                 ndr->depth++;
19444                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19445                 ndr->depth--;
19446                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19447                 ndr->depth++;
19448                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19449                 ndr->depth--;
19450                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19451                 ndr->depth--;
19452         }
19453         if (flags & NDR_OUT) {
19454                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19455                 ndr->depth++;
19456                 ndr_print_WERROR(ndr, "result", r->out.result);
19457                 ndr->depth--;
19458         }
19459         ndr->depth--;
19460 }
19461
19462 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19463 {
19464         if (flags & NDR_IN) {
19465                 if (r->in.handle == NULL) {
19466                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19467                 }
19468                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19469                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19470                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19471                 if (r->in.buffer) {
19472                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19473                 }
19474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19475         }
19476         if (flags & NDR_OUT) {
19477                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19478                 if (r->out.info) {
19479                         {
19480                                 struct ndr_push *_ndr_info;
19481                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19482                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19483                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19484                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19485                         }
19486                 }
19487                 if (r->out.needed == NULL) {
19488                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19489                 }
19490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19491                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19492         }
19493         return NDR_ERR_SUCCESS;
19494 }
19495
19496 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19497 {
19498         uint32_t _ptr_buffer;
19499         uint32_t _ptr_info;
19500         TALLOC_CTX *_mem_save_handle_0;
19501         TALLOC_CTX *_mem_save_buffer_0;
19502         TALLOC_CTX *_mem_save_info_0;
19503         TALLOC_CTX *_mem_save_needed_0;
19504         if (flags & NDR_IN) {
19505                 ZERO_STRUCT(r->out);
19506
19507                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19508                         NDR_PULL_ALLOC(ndr, r->in.handle);
19509                 }
19510                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19511                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19512                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19513                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19516                 if (_ptr_buffer) {
19517                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19518                 } else {
19519                         r->in.buffer = NULL;
19520                 }
19521                 if (r->in.buffer) {
19522                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19523                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19524                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19526                 }
19527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19528                 NDR_PULL_ALLOC(ndr, r->out.needed);
19529                 ZERO_STRUCTP(r->out.needed);
19530         }
19531         if (flags & NDR_OUT) {
19532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19533                 if (_ptr_info) {
19534                         NDR_PULL_ALLOC(ndr, r->out.info);
19535                 } else {
19536                         r->out.info = NULL;
19537                 }
19538                 if (r->out.info) {
19539                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19540                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19541                         {
19542                                 struct ndr_pull *_ndr_info;
19543                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19544                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19545                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19546                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19547                         }
19548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19549                 }
19550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19551                         NDR_PULL_ALLOC(ndr, r->out.needed);
19552                 }
19553                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19554                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19555                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19556                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19557                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19558         }
19559         return NDR_ERR_SUCCESS;
19560 }
19561
19562 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19563 {
19564         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19565         ndr->depth++;
19566         if (flags & NDR_SET_VALUES) {
19567                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19568         }
19569         if (flags & NDR_IN) {
19570                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19571                 ndr->depth++;
19572                 ndr_print_ptr(ndr, "handle", r->in.handle);
19573                 ndr->depth++;
19574                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19575                 ndr->depth--;
19576                 ndr_print_uint32(ndr, "level", r->in.level);
19577                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19578                 ndr->depth++;
19579                 if (r->in.buffer) {
19580                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19581                 }
19582                 ndr->depth--;
19583                 ndr_print_uint32(ndr, "offered", r->in.offered);
19584                 ndr->depth--;
19585         }
19586         if (flags & NDR_OUT) {
19587                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19588                 ndr->depth++;
19589                 ndr_print_ptr(ndr, "info", r->out.info);
19590                 ndr->depth++;
19591                 if (r->out.info) {
19592                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19593                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19594                 }
19595                 ndr->depth--;
19596                 ndr_print_ptr(ndr, "needed", r->out.needed);
19597                 ndr->depth++;
19598                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19599                 ndr->depth--;
19600                 ndr_print_WERROR(ndr, "result", r->out.result);
19601                 ndr->depth--;
19602         }
19603         ndr->depth--;
19604 }
19605
19606 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19607 {
19608         if (flags & NDR_IN) {
19609                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19610                 if (r->in.servername) {
19611                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19612                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19614                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19615                 }
19616                 if (r->in.info_ctr == NULL) {
19617                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19618                 }
19619                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19620         }
19621         if (flags & NDR_OUT) {
19622                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19623         }
19624         return NDR_ERR_SUCCESS;
19625 }
19626
19627 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19628 {
19629         uint32_t _ptr_servername;
19630         TALLOC_CTX *_mem_save_servername_0;
19631         TALLOC_CTX *_mem_save_info_ctr_0;
19632         if (flags & NDR_IN) {
19633                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19634                 if (_ptr_servername) {
19635                         NDR_PULL_ALLOC(ndr, r->in.servername);
19636                 } else {
19637                         r->in.servername = NULL;
19638                 }
19639                 if (r->in.servername) {
19640                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19641                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19644                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19645                                 return 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));
19646                         }
19647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19650                 }
19651                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19652                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19653                 }
19654                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19655                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19656                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19657                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19658         }
19659         if (flags & NDR_OUT) {
19660                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19661         }
19662         return NDR_ERR_SUCCESS;
19663 }
19664
19665 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19666 {
19667         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19668         ndr->depth++;
19669         if (flags & NDR_SET_VALUES) {
19670                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19671         }
19672         if (flags & NDR_IN) {
19673                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19674                 ndr->depth++;
19675                 ndr_print_ptr(ndr, "servername", r->in.servername);
19676                 ndr->depth++;
19677                 if (r->in.servername) {
19678                         ndr_print_string(ndr, "servername", r->in.servername);
19679                 }
19680                 ndr->depth--;
19681                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19682                 ndr->depth++;
19683                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19684                 ndr->depth--;
19685                 ndr->depth--;
19686         }
19687         if (flags & NDR_OUT) {
19688                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19689                 ndr->depth++;
19690                 ndr_print_WERROR(ndr, "result", r->out.result);
19691                 ndr->depth--;
19692         }
19693         ndr->depth--;
19694 }
19695
19696 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19697 {
19698         if (flags & NDR_IN) {
19699                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19700                 if (r->in.server) {
19701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19702                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19703                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19704                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19705                 }
19706                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19707                 if (r->in.environment) {
19708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19711                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19712                 }
19713                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19715                 if (r->in.buffer) {
19716                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19717                 }
19718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19719         }
19720         if (flags & NDR_OUT) {
19721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19722                 if (r->out.info) {
19723                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19724                 }
19725                 if (r->out.needed == NULL) {
19726                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19727                 }
19728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19729                 if (r->out.count == NULL) {
19730                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19731                 }
19732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19733                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19734         }
19735         return NDR_ERR_SUCCESS;
19736 }
19737
19738 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19739 {
19740         uint32_t _ptr_server;
19741         uint32_t _ptr_environment;
19742         uint32_t _ptr_buffer;
19743         uint32_t _ptr_info;
19744         TALLOC_CTX *_mem_save_server_0;
19745         TALLOC_CTX *_mem_save_environment_0;
19746         TALLOC_CTX *_mem_save_buffer_0;
19747         TALLOC_CTX *_mem_save_info_0;
19748         TALLOC_CTX *_mem_save_needed_0;
19749         TALLOC_CTX *_mem_save_count_0;
19750         if (flags & NDR_IN) {
19751                 ZERO_STRUCT(r->out);
19752
19753                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19754                 if (_ptr_server) {
19755                         NDR_PULL_ALLOC(ndr, r->in.server);
19756                 } else {
19757                         r->in.server = NULL;
19758                 }
19759                 if (r->in.server) {
19760                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19761                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19763                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19764                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19765                                 return 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));
19766                         }
19767                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19768                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19770                 }
19771                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19772                 if (_ptr_environment) {
19773                         NDR_PULL_ALLOC(ndr, r->in.environment);
19774                 } else {
19775                         r->in.environment = NULL;
19776                 }
19777                 if (r->in.environment) {
19778                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19779                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19780                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19781                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19782                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19783                                 return 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));
19784                         }
19785                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19786                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19787                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19788                 }
19789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19790                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19791                 if (_ptr_buffer) {
19792                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19793                 } else {
19794                         r->in.buffer = NULL;
19795                 }
19796                 if (r->in.buffer) {
19797                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19798                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19799                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19800                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19801                 }
19802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19803                 NDR_PULL_ALLOC(ndr, r->out.needed);
19804                 ZERO_STRUCTP(r->out.needed);
19805                 NDR_PULL_ALLOC(ndr, r->out.count);
19806                 ZERO_STRUCTP(r->out.count);
19807         }
19808         if (flags & NDR_OUT) {
19809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19810                 if (_ptr_info) {
19811                         NDR_PULL_ALLOC(ndr, r->out.info);
19812                 } else {
19813                         r->out.info = NULL;
19814                 }
19815                 if (r->out.info) {
19816                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19817                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19818                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19819                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19820                 }
19821                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19822                         NDR_PULL_ALLOC(ndr, r->out.needed);
19823                 }
19824                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19825                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19828                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19829                         NDR_PULL_ALLOC(ndr, r->out.count);
19830                 }
19831                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19832                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19833                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19834                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19835                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19836         }
19837         return NDR_ERR_SUCCESS;
19838 }
19839
19840 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
19841 {
19842         uint32_t cntr_info_0;
19843         if (flags & NDR_IN) {
19844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19845                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19846         }
19847         if (flags & NDR_OUT) {
19848                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19849                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19850                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19851                 }
19852                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19853                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19854                 }
19855         }
19856         return NDR_ERR_SUCCESS;
19857 }
19858
19859 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
19860 {
19861         uint32_t cntr_info_0;
19862         TALLOC_CTX *_mem_save_info_0;
19863         if (flags & NDR_IN) {
19864                 ZERO_STRUCT(r->out);
19865
19866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19868         }
19869         if (flags & NDR_OUT) {
19870                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19871                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19872                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19873                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19874                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19875                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19876                 }
19877                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19878                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19879                 }
19880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19881         }
19882         return NDR_ERR_SUCCESS;
19883 }
19884
19885 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
19886 {
19887         uint32_t cntr_info_2;
19888         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
19889         ndr->depth++;
19890         if (flags & NDR_SET_VALUES) {
19891                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19892         }
19893         if (flags & NDR_IN) {
19894                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
19895                 ndr->depth++;
19896                 ndr_print_ptr(ndr, "server", r->in.server);
19897                 ndr->depth++;
19898                 if (r->in.server) {
19899                         ndr_print_string(ndr, "server", r->in.server);
19900                 }
19901                 ndr->depth--;
19902                 ndr_print_ptr(ndr, "environment", r->in.environment);
19903                 ndr->depth++;
19904                 if (r->in.environment) {
19905                         ndr_print_string(ndr, "environment", r->in.environment);
19906                 }
19907                 ndr->depth--;
19908                 ndr_print_uint32(ndr, "level", r->in.level);
19909                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19910                 ndr->depth++;
19911                 if (r->in.buffer) {
19912                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19913                 }
19914                 ndr->depth--;
19915                 ndr_print_uint32(ndr, "offered", r->in.offered);
19916                 ndr->depth--;
19917         }
19918         if (flags & NDR_OUT) {
19919                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
19920                 ndr->depth++;
19921                 ndr_print_ptr(ndr, "count", r->out.count);
19922                 ndr->depth++;
19923                 ndr_print_uint32(ndr, "count", *r->out.count);
19924                 ndr->depth--;
19925                 ndr_print_ptr(ndr, "info", r->out.info);
19926                 ndr->depth++;
19927                 ndr_print_ptr(ndr, "info", *r->out.info);
19928                 ndr->depth++;
19929                 if (*r->out.info) {
19930                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19931                         ndr->depth++;
19932                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19933                                 char *idx_2=NULL;
19934                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19935                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19936                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19937                                         free(idx_2);
19938                                 }
19939                         }
19940                         ndr->depth--;
19941                 }
19942                 ndr->depth--;
19943                 ndr->depth--;
19944                 ndr_print_ptr(ndr, "needed", r->out.needed);
19945                 ndr->depth++;
19946                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19947                 ndr->depth--;
19948                 ndr_print_WERROR(ndr, "result", r->out.result);
19949                 ndr->depth--;
19950         }
19951         ndr->depth--;
19952 }
19953
19954 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
19955 {
19956         if (flags & NDR_IN) {
19957         }
19958         if (flags & NDR_OUT) {
19959                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19960         }
19961         return NDR_ERR_SUCCESS;
19962 }
19963
19964 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
19965 {
19966         if (flags & NDR_IN) {
19967         }
19968         if (flags & NDR_OUT) {
19969                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19970         }
19971         return NDR_ERR_SUCCESS;
19972 }
19973
19974 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
19975 {
19976         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
19977         ndr->depth++;
19978         if (flags & NDR_SET_VALUES) {
19979                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19980         }
19981         if (flags & NDR_IN) {
19982                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
19983                 ndr->depth++;
19984                 ndr->depth--;
19985         }
19986         if (flags & NDR_OUT) {
19987                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
19988                 ndr->depth++;
19989                 ndr_print_WERROR(ndr, "result", r->out.result);
19990                 ndr->depth--;
19991         }
19992         ndr->depth--;
19993 }
19994
19995 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
19996 {
19997         if (flags & NDR_IN) {
19998                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19999                 if (r->in.server) {
20000                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20001                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20003                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20004                 }
20005                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20006                 if (r->in.environment) {
20007                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20008                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20010                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20011                 }
20012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20014                 if (r->in.buffer) {
20015                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20016                 }
20017                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20018         }
20019         if (flags & NDR_OUT) {
20020                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20021                 if (r->out.info) {
20022                         {
20023                                 struct ndr_push *_ndr_info;
20024                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20025                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20026                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20027                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20028                         }
20029                 }
20030                 if (r->out.needed == NULL) {
20031                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20032                 }
20033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20034                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20035         }
20036         return NDR_ERR_SUCCESS;
20037 }
20038
20039 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20040 {
20041         uint32_t _ptr_server;
20042         uint32_t _ptr_environment;
20043         uint32_t _ptr_buffer;
20044         uint32_t _ptr_info;
20045         TALLOC_CTX *_mem_save_server_0;
20046         TALLOC_CTX *_mem_save_environment_0;
20047         TALLOC_CTX *_mem_save_buffer_0;
20048         TALLOC_CTX *_mem_save_info_0;
20049         TALLOC_CTX *_mem_save_needed_0;
20050         if (flags & NDR_IN) {
20051                 ZERO_STRUCT(r->out);
20052
20053                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20054                 if (_ptr_server) {
20055                         NDR_PULL_ALLOC(ndr, r->in.server);
20056                 } else {
20057                         r->in.server = NULL;
20058                 }
20059                 if (r->in.server) {
20060                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20061                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20062                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20063                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20064                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20065                                 return 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));
20066                         }
20067                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20068                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20069                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20070                 }
20071                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20072                 if (_ptr_environment) {
20073                         NDR_PULL_ALLOC(ndr, r->in.environment);
20074                 } else {
20075                         r->in.environment = NULL;
20076                 }
20077                 if (r->in.environment) {
20078                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20079                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20080                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20081                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20082                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20083                                 return 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));
20084                         }
20085                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20086                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20087                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20088                 }
20089                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20091                 if (_ptr_buffer) {
20092                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20093                 } else {
20094                         r->in.buffer = NULL;
20095                 }
20096                 if (r->in.buffer) {
20097                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20098                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20099                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20100                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20101                 }
20102                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20103                 NDR_PULL_ALLOC(ndr, r->out.needed);
20104                 ZERO_STRUCTP(r->out.needed);
20105         }
20106         if (flags & NDR_OUT) {
20107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20108                 if (_ptr_info) {
20109                         NDR_PULL_ALLOC(ndr, r->out.info);
20110                 } else {
20111                         r->out.info = NULL;
20112                 }
20113                 if (r->out.info) {
20114                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20115                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20116                         {
20117                                 struct ndr_pull *_ndr_info;
20118                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20119                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20120                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20121                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20122                         }
20123                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20124                 }
20125                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20126                         NDR_PULL_ALLOC(ndr, r->out.needed);
20127                 }
20128                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20129                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20130                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20131                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20132                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20133         }
20134         return NDR_ERR_SUCCESS;
20135 }
20136
20137 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20138 {
20139         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20140         ndr->depth++;
20141         if (flags & NDR_SET_VALUES) {
20142                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20143         }
20144         if (flags & NDR_IN) {
20145                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20146                 ndr->depth++;
20147                 ndr_print_ptr(ndr, "server", r->in.server);
20148                 ndr->depth++;
20149                 if (r->in.server) {
20150                         ndr_print_string(ndr, "server", r->in.server);
20151                 }
20152                 ndr->depth--;
20153                 ndr_print_ptr(ndr, "environment", r->in.environment);
20154                 ndr->depth++;
20155                 if (r->in.environment) {
20156                         ndr_print_string(ndr, "environment", r->in.environment);
20157                 }
20158                 ndr->depth--;
20159                 ndr_print_uint32(ndr, "level", r->in.level);
20160                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20161                 ndr->depth++;
20162                 if (r->in.buffer) {
20163                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20164                 }
20165                 ndr->depth--;
20166                 ndr_print_uint32(ndr, "offered", r->in.offered);
20167                 ndr->depth--;
20168         }
20169         if (flags & NDR_OUT) {
20170                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20171                 ndr->depth++;
20172                 ndr_print_ptr(ndr, "info", r->out.info);
20173                 ndr->depth++;
20174                 if (r->out.info) {
20175                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20176                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20177                 }
20178                 ndr->depth--;
20179                 ndr_print_ptr(ndr, "needed", r->out.needed);
20180                 ndr->depth++;
20181                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20182                 ndr->depth--;
20183                 ndr_print_WERROR(ndr, "result", r->out.result);
20184                 ndr->depth--;
20185         }
20186         ndr->depth--;
20187 }
20188
20189 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20190 {
20191         if (flags & NDR_IN) {
20192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20193                 if (r->in.server) {
20194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20196                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20198                 }
20199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20202                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20203                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20205                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20206                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20207         }
20208         if (flags & NDR_OUT) {
20209                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20210         }
20211         return NDR_ERR_SUCCESS;
20212 }
20213
20214 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20215 {
20216         uint32_t _ptr_server;
20217         TALLOC_CTX *_mem_save_server_0;
20218         if (flags & NDR_IN) {
20219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20220                 if (_ptr_server) {
20221                         NDR_PULL_ALLOC(ndr, r->in.server);
20222                 } else {
20223                         r->in.server = NULL;
20224                 }
20225                 if (r->in.server) {
20226                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20227                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20228                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20229                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20230                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20231                                 return 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));
20232                         }
20233                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20234                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20235                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20236                 }
20237                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20238                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20239                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20240                         return 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));
20241                 }
20242                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20243                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20244                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20245                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20246                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20247                         return 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));
20248                 }
20249                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20250                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20251         }
20252         if (flags & NDR_OUT) {
20253                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20254         }
20255         return NDR_ERR_SUCCESS;
20256 }
20257
20258 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20259 {
20260         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20261         ndr->depth++;
20262         if (flags & NDR_SET_VALUES) {
20263                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20264         }
20265         if (flags & NDR_IN) {
20266                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20267                 ndr->depth++;
20268                 ndr_print_ptr(ndr, "server", r->in.server);
20269                 ndr->depth++;
20270                 if (r->in.server) {
20271                         ndr_print_string(ndr, "server", r->in.server);
20272                 }
20273                 ndr->depth--;
20274                 ndr_print_string(ndr, "architecture", r->in.architecture);
20275                 ndr_print_string(ndr, "driver", r->in.driver);
20276                 ndr->depth--;
20277         }
20278         if (flags & NDR_OUT) {
20279                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20280                 ndr->depth++;
20281                 ndr_print_WERROR(ndr, "result", r->out.result);
20282                 ndr->depth--;
20283         }
20284         ndr->depth--;
20285 }
20286
20287 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20288 {
20289         if (flags & NDR_IN) {
20290                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20291                 if (r->in.server) {
20292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20293                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20294                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20295                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20296                 }
20297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20300                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20304                 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));
20305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20308                 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));
20309         }
20310         if (flags & NDR_OUT) {
20311                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20312         }
20313         return NDR_ERR_SUCCESS;
20314 }
20315
20316 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20317 {
20318         uint32_t _ptr_server;
20319         TALLOC_CTX *_mem_save_server_0;
20320         if (flags & NDR_IN) {
20321                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20322                 if (_ptr_server) {
20323                         NDR_PULL_ALLOC(ndr, r->in.server);
20324                 } else {
20325                         r->in.server = NULL;
20326                 }
20327                 if (r->in.server) {
20328                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20329                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20330                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20331                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20332                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20333                                 return 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));
20334                         }
20335                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20336                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20338                 }
20339                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20340                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20341                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20342                         return 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));
20343                 }
20344                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20345                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20346                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20347                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20348                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20349                         return 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));
20350                 }
20351                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20352                 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));
20353                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20354                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20355                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20356                         return 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));
20357                 }
20358                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20359                 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));
20360         }
20361         if (flags & NDR_OUT) {
20362                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20363         }
20364         return NDR_ERR_SUCCESS;
20365 }
20366
20367 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20368 {
20369         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20370         ndr->depth++;
20371         if (flags & NDR_SET_VALUES) {
20372                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20373         }
20374         if (flags & NDR_IN) {
20375                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20376                 ndr->depth++;
20377                 ndr_print_ptr(ndr, "server", r->in.server);
20378                 ndr->depth++;
20379                 if (r->in.server) {
20380                         ndr_print_string(ndr, "server", r->in.server);
20381                 }
20382                 ndr->depth--;
20383                 ndr_print_string(ndr, "architecture", r->in.architecture);
20384                 ndr_print_string(ndr, "path_name", r->in.path_name);
20385                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20386                 ndr->depth--;
20387         }
20388         if (flags & NDR_OUT) {
20389                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20390                 ndr->depth++;
20391                 ndr_print_WERROR(ndr, "result", r->out.result);
20392                 ndr->depth--;
20393         }
20394         ndr->depth--;
20395 }
20396
20397 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20398 {
20399         if (flags & NDR_IN) {
20400                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20401                 if (r->in.servername) {
20402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20404                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20405                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20406                 }
20407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20408                 if (r->in.environment) {
20409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20413                 }
20414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20416                 if (r->in.buffer) {
20417                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20418                 }
20419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20420         }
20421         if (flags & NDR_OUT) {
20422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20423                 if (r->out.info) {
20424                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20425                 }
20426                 if (r->out.needed == NULL) {
20427                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20428                 }
20429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20430                 if (r->out.count == NULL) {
20431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20432                 }
20433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20434                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20435         }
20436         return NDR_ERR_SUCCESS;
20437 }
20438
20439 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20440 {
20441         uint32_t _ptr_servername;
20442         uint32_t _ptr_environment;
20443         uint32_t _ptr_buffer;
20444         uint32_t _ptr_info;
20445         TALLOC_CTX *_mem_save_servername_0;
20446         TALLOC_CTX *_mem_save_environment_0;
20447         TALLOC_CTX *_mem_save_buffer_0;
20448         TALLOC_CTX *_mem_save_info_0;
20449         TALLOC_CTX *_mem_save_needed_0;
20450         TALLOC_CTX *_mem_save_count_0;
20451         if (flags & NDR_IN) {
20452                 ZERO_STRUCT(r->out);
20453
20454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20455                 if (_ptr_servername) {
20456                         NDR_PULL_ALLOC(ndr, r->in.servername);
20457                 } else {
20458                         r->in.servername = NULL;
20459                 }
20460                 if (r->in.servername) {
20461                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20462                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20463                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20464                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20465                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20466                                 return 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));
20467                         }
20468                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20469                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20470                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20471                 }
20472                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20473                 if (_ptr_environment) {
20474                         NDR_PULL_ALLOC(ndr, r->in.environment);
20475                 } else {
20476                         r->in.environment = NULL;
20477                 }
20478                 if (r->in.environment) {
20479                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20480                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20481                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20482                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20483                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20484                                 return 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));
20485                         }
20486                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20487                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20489                 }
20490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20491                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20492                 if (_ptr_buffer) {
20493                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20494                 } else {
20495                         r->in.buffer = NULL;
20496                 }
20497                 if (r->in.buffer) {
20498                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20499                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20500                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20502                 }
20503                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20504                 NDR_PULL_ALLOC(ndr, r->out.needed);
20505                 ZERO_STRUCTP(r->out.needed);
20506                 NDR_PULL_ALLOC(ndr, r->out.count);
20507                 ZERO_STRUCTP(r->out.count);
20508         }
20509         if (flags & NDR_OUT) {
20510                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20511                 if (_ptr_info) {
20512                         NDR_PULL_ALLOC(ndr, r->out.info);
20513                 } else {
20514                         r->out.info = NULL;
20515                 }
20516                 if (r->out.info) {
20517                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20518                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20519                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20521                 }
20522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20523                         NDR_PULL_ALLOC(ndr, r->out.needed);
20524                 }
20525                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20526                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20529                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20530                         NDR_PULL_ALLOC(ndr, r->out.count);
20531                 }
20532                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20533                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20534                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20535                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20537         }
20538         return NDR_ERR_SUCCESS;
20539 }
20540
20541 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20542 {
20543         uint32_t cntr_info_0;
20544         if (flags & NDR_IN) {
20545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20546                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20547         }
20548         if (flags & NDR_OUT) {
20549                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20550                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20551                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20552                 }
20553                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20554                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20555                 }
20556         }
20557         return NDR_ERR_SUCCESS;
20558 }
20559
20560 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20561 {
20562         uint32_t cntr_info_0;
20563         TALLOC_CTX *_mem_save_info_0;
20564         if (flags & NDR_IN) {
20565                 ZERO_STRUCT(r->out);
20566
20567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20569         }
20570         if (flags & NDR_OUT) {
20571                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20572                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20573                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20574                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20575                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20576                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20577                 }
20578                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20579                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20580                 }
20581                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20582         }
20583         return NDR_ERR_SUCCESS;
20584 }
20585
20586 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20587 {
20588         uint32_t cntr_info_2;
20589         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20590         ndr->depth++;
20591         if (flags & NDR_SET_VALUES) {
20592                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20593         }
20594         if (flags & NDR_IN) {
20595                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20596                 ndr->depth++;
20597                 ndr_print_ptr(ndr, "servername", r->in.servername);
20598                 ndr->depth++;
20599                 if (r->in.servername) {
20600                         ndr_print_string(ndr, "servername", r->in.servername);
20601                 }
20602                 ndr->depth--;
20603                 ndr_print_ptr(ndr, "environment", r->in.environment);
20604                 ndr->depth++;
20605                 if (r->in.environment) {
20606                         ndr_print_string(ndr, "environment", r->in.environment);
20607                 }
20608                 ndr->depth--;
20609                 ndr_print_uint32(ndr, "level", r->in.level);
20610                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20611                 ndr->depth++;
20612                 if (r->in.buffer) {
20613                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20614                 }
20615                 ndr->depth--;
20616                 ndr_print_uint32(ndr, "offered", r->in.offered);
20617                 ndr->depth--;
20618         }
20619         if (flags & NDR_OUT) {
20620                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20621                 ndr->depth++;
20622                 ndr_print_ptr(ndr, "count", r->out.count);
20623                 ndr->depth++;
20624                 ndr_print_uint32(ndr, "count", *r->out.count);
20625                 ndr->depth--;
20626                 ndr_print_ptr(ndr, "info", r->out.info);
20627                 ndr->depth++;
20628                 ndr_print_ptr(ndr, "info", *r->out.info);
20629                 ndr->depth++;
20630                 if (*r->out.info) {
20631                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20632                         ndr->depth++;
20633                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20634                                 char *idx_2=NULL;
20635                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20636                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20637                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20638                                         free(idx_2);
20639                                 }
20640                         }
20641                         ndr->depth--;
20642                 }
20643                 ndr->depth--;
20644                 ndr->depth--;
20645                 ndr_print_ptr(ndr, "needed", r->out.needed);
20646                 ndr->depth++;
20647                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20648                 ndr->depth--;
20649                 ndr_print_WERROR(ndr, "result", r->out.result);
20650                 ndr->depth--;
20651         }
20652         ndr->depth--;
20653 }
20654
20655 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20656 {
20657         if (flags & NDR_IN) {
20658                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20659                 if (r->in.server) {
20660                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20661                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20662                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20663                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20664                 }
20665                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20666                 if (r->in.environment) {
20667                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20668                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20670                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20671                 }
20672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20673                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20674                 if (r->in.buffer) {
20675                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20676                 }
20677                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20678         }
20679         if (flags & NDR_OUT) {
20680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20681                 if (r->out.info) {
20682                         {
20683                                 struct ndr_push *_ndr_info;
20684                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20685                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20686                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20687                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20688                         }
20689                 }
20690                 if (r->out.needed == NULL) {
20691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20692                 }
20693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20694                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20695         }
20696         return NDR_ERR_SUCCESS;
20697 }
20698
20699 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20700 {
20701         uint32_t _ptr_server;
20702         uint32_t _ptr_environment;
20703         uint32_t _ptr_buffer;
20704         uint32_t _ptr_info;
20705         TALLOC_CTX *_mem_save_server_0;
20706         TALLOC_CTX *_mem_save_environment_0;
20707         TALLOC_CTX *_mem_save_buffer_0;
20708         TALLOC_CTX *_mem_save_info_0;
20709         TALLOC_CTX *_mem_save_needed_0;
20710         if (flags & NDR_IN) {
20711                 ZERO_STRUCT(r->out);
20712
20713                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20714                 if (_ptr_server) {
20715                         NDR_PULL_ALLOC(ndr, r->in.server);
20716                 } else {
20717                         r->in.server = NULL;
20718                 }
20719                 if (r->in.server) {
20720                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20721                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20722                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20723                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20724                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20725                                 return 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));
20726                         }
20727                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20728                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20730                 }
20731                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20732                 if (_ptr_environment) {
20733                         NDR_PULL_ALLOC(ndr, r->in.environment);
20734                 } else {
20735                         r->in.environment = NULL;
20736                 }
20737                 if (r->in.environment) {
20738                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20739                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20740                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20741                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20742                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20743                                 return 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));
20744                         }
20745                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20746                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20748                 }
20749                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20751                 if (_ptr_buffer) {
20752                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20753                 } else {
20754                         r->in.buffer = NULL;
20755                 }
20756                 if (r->in.buffer) {
20757                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20758                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20759                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20761                 }
20762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20763                 NDR_PULL_ALLOC(ndr, r->out.needed);
20764                 ZERO_STRUCTP(r->out.needed);
20765         }
20766         if (flags & NDR_OUT) {
20767                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20768                 if (_ptr_info) {
20769                         NDR_PULL_ALLOC(ndr, r->out.info);
20770                 } else {
20771                         r->out.info = NULL;
20772                 }
20773                 if (r->out.info) {
20774                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20775                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20776                         {
20777                                 struct ndr_pull *_ndr_info;
20778                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20779                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20780                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20781                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20782                         }
20783                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20784                 }
20785                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20786                         NDR_PULL_ALLOC(ndr, r->out.needed);
20787                 }
20788                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20789                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20791                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20792                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20793         }
20794         return NDR_ERR_SUCCESS;
20795 }
20796
20797 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20798 {
20799         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20800         ndr->depth++;
20801         if (flags & NDR_SET_VALUES) {
20802                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20803         }
20804         if (flags & NDR_IN) {
20805                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20806                 ndr->depth++;
20807                 ndr_print_ptr(ndr, "server", r->in.server);
20808                 ndr->depth++;
20809                 if (r->in.server) {
20810                         ndr_print_string(ndr, "server", r->in.server);
20811                 }
20812                 ndr->depth--;
20813                 ndr_print_ptr(ndr, "environment", r->in.environment);
20814                 ndr->depth++;
20815                 if (r->in.environment) {
20816                         ndr_print_string(ndr, "environment", r->in.environment);
20817                 }
20818                 ndr->depth--;
20819                 ndr_print_uint32(ndr, "level", r->in.level);
20820                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20821                 ndr->depth++;
20822                 if (r->in.buffer) {
20823                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20824                 }
20825                 ndr->depth--;
20826                 ndr_print_uint32(ndr, "offered", r->in.offered);
20827                 ndr->depth--;
20828         }
20829         if (flags & NDR_OUT) {
20830                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
20831                 ndr->depth++;
20832                 ndr_print_ptr(ndr, "info", r->out.info);
20833                 ndr->depth++;
20834                 if (r->out.info) {
20835                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20836                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
20837                 }
20838                 ndr->depth--;
20839                 ndr_print_ptr(ndr, "needed", r->out.needed);
20840                 ndr->depth++;
20841                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20842                 ndr->depth--;
20843                 ndr_print_WERROR(ndr, "result", r->out.result);
20844                 ndr->depth--;
20845         }
20846         ndr->depth--;
20847 }
20848
20849 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
20850 {
20851         if (flags & NDR_IN) {
20852                 if (r->in.handle == NULL) {
20853                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20854                 }
20855                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20856                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20857                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20858                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20859         }
20860         if (flags & NDR_OUT) {
20861                 if (r->out.job_id == NULL) {
20862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20863                 }
20864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
20865                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20866         }
20867         return NDR_ERR_SUCCESS;
20868 }
20869
20870 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
20871 {
20872         TALLOC_CTX *_mem_save_handle_0;
20873         TALLOC_CTX *_mem_save_job_id_0;
20874         if (flags & NDR_IN) {
20875                 ZERO_STRUCT(r->out);
20876
20877                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20878                         NDR_PULL_ALLOC(ndr, r->in.handle);
20879                 }
20880                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20881                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20882                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20883                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20884                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20885                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20886                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20887                 NDR_PULL_ALLOC(ndr, r->out.job_id);
20888                 ZERO_STRUCTP(r->out.job_id);
20889         }
20890         if (flags & NDR_OUT) {
20891                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20892                         NDR_PULL_ALLOC(ndr, r->out.job_id);
20893                 }
20894                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
20895                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
20896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
20897                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
20898                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20899         }
20900         return NDR_ERR_SUCCESS;
20901 }
20902
20903 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
20904 {
20905         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
20906         ndr->depth++;
20907         if (flags & NDR_SET_VALUES) {
20908                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20909         }
20910         if (flags & NDR_IN) {
20911                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
20912                 ndr->depth++;
20913                 ndr_print_ptr(ndr, "handle", r->in.handle);
20914                 ndr->depth++;
20915                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20916                 ndr->depth--;
20917                 ndr_print_uint32(ndr, "level", r->in.level);
20918                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20919                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
20920                 ndr->depth--;
20921         }
20922         if (flags & NDR_OUT) {
20923                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
20924                 ndr->depth++;
20925                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
20926                 ndr->depth++;
20927                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
20928                 ndr->depth--;
20929                 ndr_print_WERROR(ndr, "result", r->out.result);
20930                 ndr->depth--;
20931         }
20932         ndr->depth--;
20933 }
20934
20935 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
20936 {
20937         if (flags & NDR_IN) {
20938                 if (r->in.handle == NULL) {
20939                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20940                 }
20941                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20942         }
20943         if (flags & NDR_OUT) {
20944                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20945         }
20946         return NDR_ERR_SUCCESS;
20947 }
20948
20949 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
20950 {
20951         TALLOC_CTX *_mem_save_handle_0;
20952         if (flags & NDR_IN) {
20953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20954                         NDR_PULL_ALLOC(ndr, r->in.handle);
20955                 }
20956                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20957                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20958                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20960         }
20961         if (flags & NDR_OUT) {
20962                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20963         }
20964         return NDR_ERR_SUCCESS;
20965 }
20966
20967 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
20968 {
20969         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
20970         ndr->depth++;
20971         if (flags & NDR_SET_VALUES) {
20972                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20973         }
20974         if (flags & NDR_IN) {
20975                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
20976                 ndr->depth++;
20977                 ndr_print_ptr(ndr, "handle", r->in.handle);
20978                 ndr->depth++;
20979                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20980                 ndr->depth--;
20981                 ndr->depth--;
20982         }
20983         if (flags & NDR_OUT) {
20984                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
20985                 ndr->depth++;
20986                 ndr_print_WERROR(ndr, "result", r->out.result);
20987                 ndr->depth--;
20988         }
20989         ndr->depth--;
20990 }
20991
20992 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
20993 {
20994         if (flags & NDR_IN) {
20995                 if (r->in.handle == NULL) {
20996                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20997                 }
20998                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20999                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21001         }
21002         if (flags & NDR_OUT) {
21003                 if (r->out.num_written == NULL) {
21004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21005                 }
21006                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21007                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21008         }
21009         return NDR_ERR_SUCCESS;
21010 }
21011
21012 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21013 {
21014         TALLOC_CTX *_mem_save_handle_0;
21015         TALLOC_CTX *_mem_save_num_written_0;
21016         if (flags & NDR_IN) {
21017                 ZERO_STRUCT(r->out);
21018
21019                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21020                         NDR_PULL_ALLOC(ndr, r->in.handle);
21021                 }
21022                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21023                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21024                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21025                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21026                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21028                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21029                 ZERO_STRUCTP(r->out.num_written);
21030         }
21031         if (flags & NDR_OUT) {
21032                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21033                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21034                 }
21035                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21036                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21037                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21038                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21039                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21040         }
21041         return NDR_ERR_SUCCESS;
21042 }
21043
21044 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21045 {
21046         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21047         ndr->depth++;
21048         if (flags & NDR_SET_VALUES) {
21049                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21050         }
21051         if (flags & NDR_IN) {
21052                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21053                 ndr->depth++;
21054                 ndr_print_ptr(ndr, "handle", r->in.handle);
21055                 ndr->depth++;
21056                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21057                 ndr->depth--;
21058                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21059                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21060                 ndr->depth--;
21061         }
21062         if (flags & NDR_OUT) {
21063                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21064                 ndr->depth++;
21065                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21066                 ndr->depth++;
21067                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21068                 ndr->depth--;
21069                 ndr_print_WERROR(ndr, "result", r->out.result);
21070                 ndr->depth--;
21071         }
21072         ndr->depth--;
21073 }
21074
21075 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21076 {
21077         if (flags & NDR_IN) {
21078                 if (r->in.handle == NULL) {
21079                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21080                 }
21081                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21082         }
21083         if (flags & NDR_OUT) {
21084                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21085         }
21086         return NDR_ERR_SUCCESS;
21087 }
21088
21089 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21090 {
21091         TALLOC_CTX *_mem_save_handle_0;
21092         if (flags & NDR_IN) {
21093                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21094                         NDR_PULL_ALLOC(ndr, r->in.handle);
21095                 }
21096                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21097                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21098                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21099                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21100         }
21101         if (flags & NDR_OUT) {
21102                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21103         }
21104         return NDR_ERR_SUCCESS;
21105 }
21106
21107 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21108 {
21109         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21110         ndr->depth++;
21111         if (flags & NDR_SET_VALUES) {
21112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21113         }
21114         if (flags & NDR_IN) {
21115                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21116                 ndr->depth++;
21117                 ndr_print_ptr(ndr, "handle", r->in.handle);
21118                 ndr->depth++;
21119                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21120                 ndr->depth--;
21121                 ndr->depth--;
21122         }
21123         if (flags & NDR_OUT) {
21124                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21125                 ndr->depth++;
21126                 ndr_print_WERROR(ndr, "result", r->out.result);
21127                 ndr->depth--;
21128         }
21129         ndr->depth--;
21130 }
21131
21132 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21133 {
21134         if (flags & NDR_IN) {
21135                 if (r->in.handle == NULL) {
21136                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21137                 }
21138                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21139         }
21140         if (flags & NDR_OUT) {
21141                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21142         }
21143         return NDR_ERR_SUCCESS;
21144 }
21145
21146 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21147 {
21148         TALLOC_CTX *_mem_save_handle_0;
21149         if (flags & NDR_IN) {
21150                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21151                         NDR_PULL_ALLOC(ndr, r->in.handle);
21152                 }
21153                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21154                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21155                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21156                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21157         }
21158         if (flags & NDR_OUT) {
21159                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21160         }
21161         return NDR_ERR_SUCCESS;
21162 }
21163
21164 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21165 {
21166         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21167         ndr->depth++;
21168         if (flags & NDR_SET_VALUES) {
21169                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21170         }
21171         if (flags & NDR_IN) {
21172                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21173                 ndr->depth++;
21174                 ndr_print_ptr(ndr, "handle", r->in.handle);
21175                 ndr->depth++;
21176                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21177                 ndr->depth--;
21178                 ndr->depth--;
21179         }
21180         if (flags & NDR_OUT) {
21181                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21182                 ndr->depth++;
21183                 ndr_print_WERROR(ndr, "result", r->out.result);
21184                 ndr->depth--;
21185         }
21186         ndr->depth--;
21187 }
21188
21189 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21190 {
21191         if (flags & NDR_IN) {
21192                 if (r->in.handle == NULL) {
21193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21194                 }
21195                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21196                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21197         }
21198         if (flags & NDR_OUT) {
21199                 if (r->out.data == NULL) {
21200                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21201                 }
21202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21203                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21204                 if (r->out._data_size == NULL) {
21205                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21206                 }
21207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21208                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21209         }
21210         return NDR_ERR_SUCCESS;
21211 }
21212
21213 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21214 {
21215         TALLOC_CTX *_mem_save_handle_0;
21216         TALLOC_CTX *_mem_save__data_size_0;
21217         if (flags & NDR_IN) {
21218                 ZERO_STRUCT(r->out);
21219
21220                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21221                         NDR_PULL_ALLOC(ndr, r->in.handle);
21222                 }
21223                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21224                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21225                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21228                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21229                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21230                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21231                 ZERO_STRUCTP(r->out._data_size);
21232         }
21233         if (flags & NDR_OUT) {
21234                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21235                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21236                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21237                 }
21238                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21239                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21240                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21241                 }
21242                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21243                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21244                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21245                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21246                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21247                 if (r->out.data) {
21248                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21249                 }
21250         }
21251         return NDR_ERR_SUCCESS;
21252 }
21253
21254 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21255 {
21256         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21257         ndr->depth++;
21258         if (flags & NDR_SET_VALUES) {
21259                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21260         }
21261         if (flags & NDR_IN) {
21262                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21263                 ndr->depth++;
21264                 ndr_print_ptr(ndr, "handle", r->in.handle);
21265                 ndr->depth++;
21266                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21267                 ndr->depth--;
21268                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21269                 ndr->depth--;
21270         }
21271         if (flags & NDR_OUT) {
21272                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21273                 ndr->depth++;
21274                 ndr_print_ptr(ndr, "data", r->out.data);
21275                 ndr->depth++;
21276                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21277                 ndr->depth--;
21278                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21279                 ndr->depth++;
21280                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21281                 ndr->depth--;
21282                 ndr_print_WERROR(ndr, "result", r->out.result);
21283                 ndr->depth--;
21284         }
21285         ndr->depth--;
21286 }
21287
21288 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21289 {
21290         if (flags & NDR_IN) {
21291                 if (r->in.handle == NULL) {
21292                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21293                 }
21294                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21295         }
21296         if (flags & NDR_OUT) {
21297                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21298         }
21299         return NDR_ERR_SUCCESS;
21300 }
21301
21302 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21303 {
21304         TALLOC_CTX *_mem_save_handle_0;
21305         if (flags & NDR_IN) {
21306                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21307                         NDR_PULL_ALLOC(ndr, r->in.handle);
21308                 }
21309                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21310                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21311                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21312                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21313         }
21314         if (flags & NDR_OUT) {
21315                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21316         }
21317         return NDR_ERR_SUCCESS;
21318 }
21319
21320 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21321 {
21322         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21323         ndr->depth++;
21324         if (flags & NDR_SET_VALUES) {
21325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21326         }
21327         if (flags & NDR_IN) {
21328                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21329                 ndr->depth++;
21330                 ndr_print_ptr(ndr, "handle", r->in.handle);
21331                 ndr->depth++;
21332                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21333                 ndr->depth--;
21334                 ndr->depth--;
21335         }
21336         if (flags & NDR_OUT) {
21337                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21338                 ndr->depth++;
21339                 ndr_print_WERROR(ndr, "result", r->out.result);
21340                 ndr->depth--;
21341         }
21342         ndr->depth--;
21343 }
21344
21345 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21346 {
21347         if (flags & NDR_IN) {
21348                 if (r->in.handle == NULL) {
21349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21350                 }
21351                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21354                 if (r->in.buffer) {
21355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21356                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21357                 }
21358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21359         }
21360         if (flags & NDR_OUT) {
21361                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21362                 if (r->out.buffer) {
21363                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21364                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21365                 }
21366                 if (r->out.needed == NULL) {
21367                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21368                 }
21369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21370                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21371         }
21372         return NDR_ERR_SUCCESS;
21373 }
21374
21375 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21376 {
21377         uint32_t _ptr_buffer;
21378         TALLOC_CTX *_mem_save_handle_0;
21379         TALLOC_CTX *_mem_save_buffer_0;
21380         TALLOC_CTX *_mem_save_needed_0;
21381         if (flags & NDR_IN) {
21382                 ZERO_STRUCT(r->out);
21383
21384                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21385                         NDR_PULL_ALLOC(ndr, r->in.handle);
21386                 }
21387                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21388                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21389                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21390                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21392                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21393                 if (_ptr_buffer) {
21394                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21395                 } else {
21396                         r->in.buffer = NULL;
21397                 }
21398                 if (r->in.buffer) {
21399                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21400                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21401                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21402                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21403                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21404                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21405                 }
21406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21407                 NDR_PULL_ALLOC(ndr, r->out.needed);
21408                 ZERO_STRUCTP(r->out.needed);
21409                 if (r->in.buffer) {
21410                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21411                 }
21412         }
21413         if (flags & NDR_OUT) {
21414                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21415                 if (_ptr_buffer) {
21416                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21417                 } else {
21418                         r->out.buffer = NULL;
21419                 }
21420                 if (r->out.buffer) {
21421                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21422                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21423                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21424                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21425                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21427                 }
21428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21429                         NDR_PULL_ALLOC(ndr, r->out.needed);
21430                 }
21431                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21432                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21435                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21436                 if (r->out.buffer) {
21437                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21438                 }
21439         }
21440         return NDR_ERR_SUCCESS;
21441 }
21442
21443 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21444 {
21445         ndr_print_struct(ndr, name, "spoolss_AddJob");
21446         ndr->depth++;
21447         if (flags & NDR_SET_VALUES) {
21448                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21449         }
21450         if (flags & NDR_IN) {
21451                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21452                 ndr->depth++;
21453                 ndr_print_ptr(ndr, "handle", r->in.handle);
21454                 ndr->depth++;
21455                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21456                 ndr->depth--;
21457                 ndr_print_uint32(ndr, "level", r->in.level);
21458                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21459                 ndr->depth++;
21460                 if (r->in.buffer) {
21461                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21462                 }
21463                 ndr->depth--;
21464                 ndr_print_uint32(ndr, "offered", r->in.offered);
21465                 ndr->depth--;
21466         }
21467         if (flags & NDR_OUT) {
21468                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21469                 ndr->depth++;
21470                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21471                 ndr->depth++;
21472                 if (r->out.buffer) {
21473                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21474                 }
21475                 ndr->depth--;
21476                 ndr_print_ptr(ndr, "needed", r->out.needed);
21477                 ndr->depth++;
21478                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21479                 ndr->depth--;
21480                 ndr_print_WERROR(ndr, "result", r->out.result);
21481                 ndr->depth--;
21482         }
21483         ndr->depth--;
21484 }
21485
21486 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21487 {
21488         if (flags & NDR_IN) {
21489                 if (r->in.handle == NULL) {
21490                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21491                 }
21492                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21494         }
21495         if (flags & NDR_OUT) {
21496                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21497         }
21498         return NDR_ERR_SUCCESS;
21499 }
21500
21501 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21502 {
21503         TALLOC_CTX *_mem_save_handle_0;
21504         if (flags & NDR_IN) {
21505                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21506                         NDR_PULL_ALLOC(ndr, r->in.handle);
21507                 }
21508                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21509                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21510                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21511                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21513         }
21514         if (flags & NDR_OUT) {
21515                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21516         }
21517         return NDR_ERR_SUCCESS;
21518 }
21519
21520 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21521 {
21522         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21523         ndr->depth++;
21524         if (flags & NDR_SET_VALUES) {
21525                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21526         }
21527         if (flags & NDR_IN) {
21528                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21529                 ndr->depth++;
21530                 ndr_print_ptr(ndr, "handle", r->in.handle);
21531                 ndr->depth++;
21532                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21533                 ndr->depth--;
21534                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21535                 ndr->depth--;
21536         }
21537         if (flags & NDR_OUT) {
21538                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21539                 ndr->depth++;
21540                 ndr_print_WERROR(ndr, "result", r->out.result);
21541                 ndr->depth--;
21542         }
21543         ndr->depth--;
21544 }
21545
21546 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21547 {
21548         if (flags & NDR_IN) {
21549                 if (r->in.handle == NULL) {
21550                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21551                 }
21552                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21555                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21556                 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));
21557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21558         }
21559         if (flags & NDR_OUT) {
21560                 if (r->out.type == NULL) {
21561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21562                 }
21563                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, *r->out.type));
21564                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21565                 if (r->out.needed == NULL) {
21566                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21567                 }
21568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21569                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21570         }
21571         return NDR_ERR_SUCCESS;
21572 }
21573
21574 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21575 {
21576         TALLOC_CTX *_mem_save_handle_0;
21577         TALLOC_CTX *_mem_save_type_0;
21578         TALLOC_CTX *_mem_save_needed_0;
21579         if (flags & NDR_IN) {
21580                 ZERO_STRUCT(r->out);
21581
21582                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21583                         NDR_PULL_ALLOC(ndr, r->in.handle);
21584                 }
21585                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21586                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21587                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21588                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21589                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21590                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21591                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21592                         return 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));
21593                 }
21594                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21595                 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));
21596                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21597                 NDR_PULL_ALLOC(ndr, r->out.type);
21598                 ZERO_STRUCTP(r->out.type);
21599                 NDR_PULL_ALLOC(ndr, r->out.needed);
21600                 ZERO_STRUCTP(r->out.needed);
21601         }
21602         if (flags & NDR_OUT) {
21603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21604                         NDR_PULL_ALLOC(ndr, r->out.type);
21605                 }
21606                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21607                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21608                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->out.type));
21609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21610                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.data));
21611                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21612                         NDR_PULL_ALLOC(ndr, r->out.needed);
21613                 }
21614                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21615                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21617                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21618                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21619         }
21620         return NDR_ERR_SUCCESS;
21621 }
21622
21623 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21624 {
21625         if (flags & NDR_IN) {
21626                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21627         }
21628         if (flags & NDR_OUT) {
21629                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21630                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21631         }
21632         return NDR_ERR_SUCCESS;
21633 }
21634
21635 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21636 {
21637         if (flags & NDR_IN) {
21638                 ZERO_STRUCT(r->out);
21639
21640                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21641         }
21642         if (flags & NDR_OUT) {
21643                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.data, r->in.type));
21644                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21645         }
21646         return NDR_ERR_SUCCESS;
21647 }
21648
21649 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21650 {
21651         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21652         ndr->depth++;
21653         if (flags & NDR_SET_VALUES) {
21654                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21655         }
21656         if (flags & NDR_IN) {
21657                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21658                 ndr->depth++;
21659                 ndr_print_ptr(ndr, "handle", r->in.handle);
21660                 ndr->depth++;
21661                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21662                 ndr->depth--;
21663                 ndr_print_string(ndr, "value_name", r->in.value_name);
21664                 ndr_print_uint32(ndr, "offered", r->in.offered);
21665                 ndr->depth--;
21666         }
21667         if (flags & NDR_OUT) {
21668                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21669                 ndr->depth++;
21670                 ndr_print_ptr(ndr, "type", r->out.type);
21671                 ndr->depth++;
21672                 ndr_print_spoolss_PrinterDataType(ndr, "type", *r->out.type);
21673                 ndr->depth--;
21674                 ndr_print_set_switch_value(ndr, &r->out.data, *r->out.type);
21675                 ndr_print_spoolss_PrinterData(ndr, "data", &r->out.data);
21676                 ndr_print_ptr(ndr, "needed", r->out.needed);
21677                 ndr->depth++;
21678                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21679                 ndr->depth--;
21680                 ndr_print_WERROR(ndr, "result", r->out.result);
21681                 ndr->depth--;
21682         }
21683         ndr->depth--;
21684 }
21685
21686 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21687 {
21688         if (flags & NDR_IN) {
21689                 if (r->in.handle == NULL) {
21690                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21691                 }
21692                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21693                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21696                 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));
21697                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21698                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21700         }
21701         if (flags & NDR_OUT) {
21702                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21703         }
21704         return NDR_ERR_SUCCESS;
21705 }
21706
21707 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21708 {
21709         if (flags & NDR_IN) {
21710                 NDR_CHECK(ndr_push_spoolss_PrinterDataType(ndr, NDR_SCALARS, r->in.type));
21711         }
21712         if (flags & NDR_OUT) {
21713                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.data, r->in.type));
21714                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, &r->out.data));
21715         }
21716         return NDR_ERR_SUCCESS;
21717 }
21718
21719 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21720 {
21721         TALLOC_CTX *_mem_save_handle_0;
21722         if (flags & NDR_IN) {
21723                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21724                         NDR_PULL_ALLOC(ndr, r->in.handle);
21725                 }
21726                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21727                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21728                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21729                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21730                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21731                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21732                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21733                         return 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));
21734                 }
21735                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21736                 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));
21737                 NDR_CHECK(ndr_pull_spoolss_PrinterDataType(ndr, NDR_SCALARS, &r->in.type));
21738                 {
21739                         struct ndr_pull *_ndr_data;
21740                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21741                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21742                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21743                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21744                 }
21745                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21746         }
21747         if (flags & NDR_OUT) {
21748                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21749         }
21750         return NDR_ERR_SUCCESS;
21751 }
21752
21753 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21754 {
21755         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21756         ndr->depth++;
21757         if (flags & NDR_SET_VALUES) {
21758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21759         }
21760         if (flags & NDR_IN) {
21761                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21762                 ndr->depth++;
21763                 ndr_print_ptr(ndr, "handle", r->in.handle);
21764                 ndr->depth++;
21765                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21766                 ndr->depth--;
21767                 ndr_print_string(ndr, "value_name", r->in.value_name);
21768                 ndr_print_spoolss_PrinterDataType(ndr, "type", r->in.type);
21769                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21770                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21771                 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);
21772                 ndr->depth--;
21773         }
21774         if (flags & NDR_OUT) {
21775                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21776                 ndr->depth++;
21777                 ndr_print_WERROR(ndr, "result", r->out.result);
21778                 ndr->depth--;
21779         }
21780         ndr->depth--;
21781 }
21782
21783 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
21784 {
21785         if (flags & NDR_IN) {
21786         }
21787         if (flags & NDR_OUT) {
21788                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21789         }
21790         return NDR_ERR_SUCCESS;
21791 }
21792
21793 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
21794 {
21795         if (flags & NDR_IN) {
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_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
21804 {
21805         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
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_WaitForPrinterChange");
21812                 ndr->depth++;
21813                 ndr->depth--;
21814         }
21815         if (flags & NDR_OUT) {
21816                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
21817                 ndr->depth++;
21818                 ndr_print_WERROR(ndr, "result", r->out.result);
21819                 ndr->depth--;
21820         }
21821         ndr->depth--;
21822 }
21823
21824 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
21825 {
21826         if (flags & NDR_IN) {
21827                 if (r->in.handle == NULL) {
21828                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21829                 }
21830                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21831         }
21832         if (flags & NDR_OUT) {
21833                 if (r->out.handle == NULL) {
21834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21835                 }
21836                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21837                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21838         }
21839         return NDR_ERR_SUCCESS;
21840 }
21841
21842 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
21843 {
21844         TALLOC_CTX *_mem_save_handle_0;
21845         if (flags & NDR_IN) {
21846                 ZERO_STRUCT(r->out);
21847
21848                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21849                         NDR_PULL_ALLOC(ndr, r->in.handle);
21850                 }
21851                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21852                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21853                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21854                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21855                 NDR_PULL_ALLOC(ndr, r->out.handle);
21856                 *r->out.handle = *r->in.handle;
21857         }
21858         if (flags & NDR_OUT) {
21859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21860                         NDR_PULL_ALLOC(ndr, r->out.handle);
21861                 }
21862                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21863                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21864                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21866                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21867         }
21868         return NDR_ERR_SUCCESS;
21869 }
21870
21871 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
21872 {
21873         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
21874         ndr->depth++;
21875         if (flags & NDR_SET_VALUES) {
21876                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21877         }
21878         if (flags & NDR_IN) {
21879                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
21880                 ndr->depth++;
21881                 ndr_print_ptr(ndr, "handle", r->in.handle);
21882                 ndr->depth++;
21883                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21884                 ndr->depth--;
21885                 ndr->depth--;
21886         }
21887         if (flags & NDR_OUT) {
21888                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
21889                 ndr->depth++;
21890                 ndr_print_ptr(ndr, "handle", r->out.handle);
21891                 ndr->depth++;
21892                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21893                 ndr->depth--;
21894                 ndr_print_WERROR(ndr, "result", r->out.result);
21895                 ndr->depth--;
21896         }
21897         ndr->depth--;
21898 }
21899
21900 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
21901 {
21902         if (flags & NDR_IN) {
21903                 if (r->in.handle == NULL) {
21904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21905                 }
21906                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21908                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21909                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21910         }
21911         if (flags & NDR_OUT) {
21912                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21913         }
21914         return NDR_ERR_SUCCESS;
21915 }
21916
21917 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
21918 {
21919         TALLOC_CTX *_mem_save_handle_0;
21920         if (flags & NDR_IN) {
21921                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21922                         NDR_PULL_ALLOC(ndr, r->in.handle);
21923                 }
21924                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21925                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21926                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21927                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21929                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21930                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21931         }
21932         if (flags & NDR_OUT) {
21933                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21934         }
21935         return NDR_ERR_SUCCESS;
21936 }
21937
21938 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
21939 {
21940         ndr_print_struct(ndr, name, "spoolss_AddForm");
21941         ndr->depth++;
21942         if (flags & NDR_SET_VALUES) {
21943                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21944         }
21945         if (flags & NDR_IN) {
21946                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
21947                 ndr->depth++;
21948                 ndr_print_ptr(ndr, "handle", r->in.handle);
21949                 ndr->depth++;
21950                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21951                 ndr->depth--;
21952                 ndr_print_uint32(ndr, "level", r->in.level);
21953                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21954                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
21955                 ndr->depth--;
21956         }
21957         if (flags & NDR_OUT) {
21958                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
21959                 ndr->depth++;
21960                 ndr_print_WERROR(ndr, "result", r->out.result);
21961                 ndr->depth--;
21962         }
21963         ndr->depth--;
21964 }
21965
21966 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
21967 {
21968         if (flags & NDR_IN) {
21969                 if (r->in.handle == NULL) {
21970                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21971                 }
21972                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21973                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21974                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
21976                 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));
21977         }
21978         if (flags & NDR_OUT) {
21979                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21980         }
21981         return NDR_ERR_SUCCESS;
21982 }
21983
21984 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
21985 {
21986         TALLOC_CTX *_mem_save_handle_0;
21987         if (flags & NDR_IN) {
21988                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21989                         NDR_PULL_ALLOC(ndr, r->in.handle);
21990                 }
21991                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21992                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21993                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21995                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
21996                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
21997                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
21998                         return 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));
21999                 }
22000                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22001                 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));
22002         }
22003         if (flags & NDR_OUT) {
22004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22005         }
22006         return NDR_ERR_SUCCESS;
22007 }
22008
22009 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22010 {
22011         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22012         ndr->depth++;
22013         if (flags & NDR_SET_VALUES) {
22014                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22015         }
22016         if (flags & NDR_IN) {
22017                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22018                 ndr->depth++;
22019                 ndr_print_ptr(ndr, "handle", r->in.handle);
22020                 ndr->depth++;
22021                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22022                 ndr->depth--;
22023                 ndr_print_string(ndr, "form_name", r->in.form_name);
22024                 ndr->depth--;
22025         }
22026         if (flags & NDR_OUT) {
22027                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22028                 ndr->depth++;
22029                 ndr_print_WERROR(ndr, "result", r->out.result);
22030                 ndr->depth--;
22031         }
22032         ndr->depth--;
22033 }
22034
22035 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22036 {
22037         if (flags & NDR_IN) {
22038                 if (r->in.handle == NULL) {
22039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22040                 }
22041                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22045                 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));
22046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22048                 if (r->in.buffer) {
22049                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22050                 }
22051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22052         }
22053         if (flags & NDR_OUT) {
22054                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22055                 if (r->out.info) {
22056                         {
22057                                 struct ndr_push *_ndr_info;
22058                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22059                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22060                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22061                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22062                         }
22063                 }
22064                 if (r->out.needed == NULL) {
22065                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22066                 }
22067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22068                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22069         }
22070         return NDR_ERR_SUCCESS;
22071 }
22072
22073 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22074 {
22075         uint32_t _ptr_buffer;
22076         uint32_t _ptr_info;
22077         TALLOC_CTX *_mem_save_handle_0;
22078         TALLOC_CTX *_mem_save_buffer_0;
22079         TALLOC_CTX *_mem_save_info_0;
22080         TALLOC_CTX *_mem_save_needed_0;
22081         if (flags & NDR_IN) {
22082                 ZERO_STRUCT(r->out);
22083
22084                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22085                         NDR_PULL_ALLOC(ndr, r->in.handle);
22086                 }
22087                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22088                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22089                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22090                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22091                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22092                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22093                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22094                         return 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));
22095                 }
22096                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22097                 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));
22098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22100                 if (_ptr_buffer) {
22101                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22102                 } else {
22103                         r->in.buffer = NULL;
22104                 }
22105                 if (r->in.buffer) {
22106                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22107                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22108                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22110                 }
22111                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22112                 NDR_PULL_ALLOC(ndr, r->out.needed);
22113                 ZERO_STRUCTP(r->out.needed);
22114         }
22115         if (flags & NDR_OUT) {
22116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22117                 if (_ptr_info) {
22118                         NDR_PULL_ALLOC(ndr, r->out.info);
22119                 } else {
22120                         r->out.info = NULL;
22121                 }
22122                 if (r->out.info) {
22123                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22124                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22125                         {
22126                                 struct ndr_pull *_ndr_info;
22127                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22128                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22129                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22130                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22131                         }
22132                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22133                 }
22134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22135                         NDR_PULL_ALLOC(ndr, r->out.needed);
22136                 }
22137                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22138                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22141                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22142         }
22143         return NDR_ERR_SUCCESS;
22144 }
22145
22146 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22147 {
22148         ndr_print_struct(ndr, name, "spoolss_GetForm");
22149         ndr->depth++;
22150         if (flags & NDR_SET_VALUES) {
22151                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22152         }
22153         if (flags & NDR_IN) {
22154                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22155                 ndr->depth++;
22156                 ndr_print_ptr(ndr, "handle", r->in.handle);
22157                 ndr->depth++;
22158                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22159                 ndr->depth--;
22160                 ndr_print_string(ndr, "form_name", r->in.form_name);
22161                 ndr_print_uint32(ndr, "level", r->in.level);
22162                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22163                 ndr->depth++;
22164                 if (r->in.buffer) {
22165                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22166                 }
22167                 ndr->depth--;
22168                 ndr_print_uint32(ndr, "offered", r->in.offered);
22169                 ndr->depth--;
22170         }
22171         if (flags & NDR_OUT) {
22172                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22173                 ndr->depth++;
22174                 ndr_print_ptr(ndr, "info", r->out.info);
22175                 ndr->depth++;
22176                 if (r->out.info) {
22177                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22178                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22179                 }
22180                 ndr->depth--;
22181                 ndr_print_ptr(ndr, "needed", r->out.needed);
22182                 ndr->depth++;
22183                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22184                 ndr->depth--;
22185                 ndr_print_WERROR(ndr, "result", r->out.result);
22186                 ndr->depth--;
22187         }
22188         ndr->depth--;
22189 }
22190
22191 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22192 {
22193         if (flags & NDR_IN) {
22194                 if (r->in.handle == NULL) {
22195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22196                 }
22197                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22201                 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));
22202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22203                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22204                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22205         }
22206         if (flags & NDR_OUT) {
22207                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22208         }
22209         return NDR_ERR_SUCCESS;
22210 }
22211
22212 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22213 {
22214         TALLOC_CTX *_mem_save_handle_0;
22215         if (flags & NDR_IN) {
22216                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22217                         NDR_PULL_ALLOC(ndr, r->in.handle);
22218                 }
22219                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22220                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22221                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22222                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22223                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22224                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22225                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22226                         return 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));
22227                 }
22228                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22229                 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));
22230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22231                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22232                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22233         }
22234         if (flags & NDR_OUT) {
22235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22236         }
22237         return NDR_ERR_SUCCESS;
22238 }
22239
22240 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22241 {
22242         ndr_print_struct(ndr, name, "spoolss_SetForm");
22243         ndr->depth++;
22244         if (flags & NDR_SET_VALUES) {
22245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22246         }
22247         if (flags & NDR_IN) {
22248                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22249                 ndr->depth++;
22250                 ndr_print_ptr(ndr, "handle", r->in.handle);
22251                 ndr->depth++;
22252                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22253                 ndr->depth--;
22254                 ndr_print_string(ndr, "form_name", r->in.form_name);
22255                 ndr_print_uint32(ndr, "level", r->in.level);
22256                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22257                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22258                 ndr->depth--;
22259         }
22260         if (flags & NDR_OUT) {
22261                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22262                 ndr->depth++;
22263                 ndr_print_WERROR(ndr, "result", r->out.result);
22264                 ndr->depth--;
22265         }
22266         ndr->depth--;
22267 }
22268
22269 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22270 {
22271         if (flags & NDR_IN) {
22272                 if (r->in.handle == NULL) {
22273                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22274                 }
22275                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22277                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22278                 if (r->in.buffer) {
22279                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22280                 }
22281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22282         }
22283         if (flags & NDR_OUT) {
22284                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22285                 if (r->out.info) {
22286                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22287                 }
22288                 if (r->out.needed == NULL) {
22289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22290                 }
22291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22292                 if (r->out.count == NULL) {
22293                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22294                 }
22295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22296                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22297         }
22298         return NDR_ERR_SUCCESS;
22299 }
22300
22301 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22302 {
22303         uint32_t _ptr_buffer;
22304         uint32_t _ptr_info;
22305         TALLOC_CTX *_mem_save_handle_0;
22306         TALLOC_CTX *_mem_save_buffer_0;
22307         TALLOC_CTX *_mem_save_info_0;
22308         TALLOC_CTX *_mem_save_needed_0;
22309         TALLOC_CTX *_mem_save_count_0;
22310         if (flags & NDR_IN) {
22311                 ZERO_STRUCT(r->out);
22312
22313                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22314                         NDR_PULL_ALLOC(ndr, r->in.handle);
22315                 }
22316                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22317                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22318                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22319                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22320                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22321                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22322                 if (_ptr_buffer) {
22323                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22324                 } else {
22325                         r->in.buffer = NULL;
22326                 }
22327                 if (r->in.buffer) {
22328                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22329                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22330                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22332                 }
22333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22334                 NDR_PULL_ALLOC(ndr, r->out.needed);
22335                 ZERO_STRUCTP(r->out.needed);
22336                 NDR_PULL_ALLOC(ndr, r->out.count);
22337                 ZERO_STRUCTP(r->out.count);
22338         }
22339         if (flags & NDR_OUT) {
22340                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22341                 if (_ptr_info) {
22342                         NDR_PULL_ALLOC(ndr, r->out.info);
22343                 } else {
22344                         r->out.info = NULL;
22345                 }
22346                 if (r->out.info) {
22347                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22348                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22349                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22350                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22351                 }
22352                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22353                         NDR_PULL_ALLOC(ndr, r->out.needed);
22354                 }
22355                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22356                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22357                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22358                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22359                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22360                         NDR_PULL_ALLOC(ndr, r->out.count);
22361                 }
22362                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22363                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22366                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22367         }
22368         return NDR_ERR_SUCCESS;
22369 }
22370
22371 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22372 {
22373         uint32_t cntr_info_0;
22374         if (flags & NDR_IN) {
22375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22377         }
22378         if (flags & NDR_OUT) {
22379                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22380                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22381                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22382                 }
22383                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22384                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22385                 }
22386         }
22387         return NDR_ERR_SUCCESS;
22388 }
22389
22390 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22391 {
22392         uint32_t cntr_info_0;
22393         TALLOC_CTX *_mem_save_info_0;
22394         if (flags & NDR_IN) {
22395                 ZERO_STRUCT(r->out);
22396
22397                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22399         }
22400         if (flags & NDR_OUT) {
22401                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22402                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22403                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22404                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22405                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22406                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22407                 }
22408                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22409                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22410                 }
22411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22412         }
22413         return NDR_ERR_SUCCESS;
22414 }
22415
22416 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22417 {
22418         uint32_t cntr_info_2;
22419         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22420         ndr->depth++;
22421         if (flags & NDR_SET_VALUES) {
22422                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22423         }
22424         if (flags & NDR_IN) {
22425                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22426                 ndr->depth++;
22427                 ndr_print_ptr(ndr, "handle", r->in.handle);
22428                 ndr->depth++;
22429                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22430                 ndr->depth--;
22431                 ndr_print_uint32(ndr, "level", r->in.level);
22432                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22433                 ndr->depth++;
22434                 if (r->in.buffer) {
22435                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22436                 }
22437                 ndr->depth--;
22438                 ndr_print_uint32(ndr, "offered", r->in.offered);
22439                 ndr->depth--;
22440         }
22441         if (flags & NDR_OUT) {
22442                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22443                 ndr->depth++;
22444                 ndr_print_ptr(ndr, "count", r->out.count);
22445                 ndr->depth++;
22446                 ndr_print_uint32(ndr, "count", *r->out.count);
22447                 ndr->depth--;
22448                 ndr_print_ptr(ndr, "info", r->out.info);
22449                 ndr->depth++;
22450                 ndr_print_ptr(ndr, "info", *r->out.info);
22451                 ndr->depth++;
22452                 if (*r->out.info) {
22453                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22454                         ndr->depth++;
22455                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22456                                 char *idx_2=NULL;
22457                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22458                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22459                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22460                                         free(idx_2);
22461                                 }
22462                         }
22463                         ndr->depth--;
22464                 }
22465                 ndr->depth--;
22466                 ndr->depth--;
22467                 ndr_print_ptr(ndr, "needed", r->out.needed);
22468                 ndr->depth++;
22469                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22470                 ndr->depth--;
22471                 ndr_print_WERROR(ndr, "result", r->out.result);
22472                 ndr->depth--;
22473         }
22474         ndr->depth--;
22475 }
22476
22477 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22478 {
22479         if (flags & NDR_IN) {
22480                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22481                 if (r->in.servername) {
22482                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22483                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22484                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22485                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22486                 }
22487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22488                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22489                 if (r->in.buffer) {
22490                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22491                 }
22492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22493         }
22494         if (flags & NDR_OUT) {
22495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22496                 if (r->out.info) {
22497                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22498                 }
22499                 if (r->out.needed == NULL) {
22500                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22501                 }
22502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22503                 if (r->out.count == NULL) {
22504                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22505                 }
22506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22507                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22508         }
22509         return NDR_ERR_SUCCESS;
22510 }
22511
22512 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22513 {
22514         uint32_t _ptr_servername;
22515         uint32_t _ptr_buffer;
22516         uint32_t _ptr_info;
22517         TALLOC_CTX *_mem_save_servername_0;
22518         TALLOC_CTX *_mem_save_buffer_0;
22519         TALLOC_CTX *_mem_save_info_0;
22520         TALLOC_CTX *_mem_save_needed_0;
22521         TALLOC_CTX *_mem_save_count_0;
22522         if (flags & NDR_IN) {
22523                 ZERO_STRUCT(r->out);
22524
22525                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22526                 if (_ptr_servername) {
22527                         NDR_PULL_ALLOC(ndr, r->in.servername);
22528                 } else {
22529                         r->in.servername = NULL;
22530                 }
22531                 if (r->in.servername) {
22532                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22533                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22534                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22535                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22536                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22537                                 return 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));
22538                         }
22539                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22540                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22541                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22542                 }
22543                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22544                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22545                 if (_ptr_buffer) {
22546                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22547                 } else {
22548                         r->in.buffer = NULL;
22549                 }
22550                 if (r->in.buffer) {
22551                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22552                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22553                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22555                 }
22556                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22557                 NDR_PULL_ALLOC(ndr, r->out.needed);
22558                 ZERO_STRUCTP(r->out.needed);
22559                 NDR_PULL_ALLOC(ndr, r->out.count);
22560                 ZERO_STRUCTP(r->out.count);
22561         }
22562         if (flags & NDR_OUT) {
22563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22564                 if (_ptr_info) {
22565                         NDR_PULL_ALLOC(ndr, r->out.info);
22566                 } else {
22567                         r->out.info = NULL;
22568                 }
22569                 if (r->out.info) {
22570                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22571                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22572                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22573                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22574                 }
22575                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22576                         NDR_PULL_ALLOC(ndr, r->out.needed);
22577                 }
22578                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22579                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22581                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22582                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22583                         NDR_PULL_ALLOC(ndr, r->out.count);
22584                 }
22585                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22586                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22588                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22590         }
22591         return NDR_ERR_SUCCESS;
22592 }
22593
22594 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22595 {
22596         uint32_t cntr_info_0;
22597         if (flags & NDR_IN) {
22598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22600         }
22601         if (flags & NDR_OUT) {
22602                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22603                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22604                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22605                 }
22606                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22607                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22608                 }
22609         }
22610         return NDR_ERR_SUCCESS;
22611 }
22612
22613 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22614 {
22615         uint32_t cntr_info_0;
22616         TALLOC_CTX *_mem_save_info_0;
22617         if (flags & NDR_IN) {
22618                 ZERO_STRUCT(r->out);
22619
22620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22621                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22622         }
22623         if (flags & NDR_OUT) {
22624                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22625                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22626                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22627                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22628                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22629                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22630                 }
22631                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22632                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22633                 }
22634                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22635         }
22636         return NDR_ERR_SUCCESS;
22637 }
22638
22639 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22640 {
22641         uint32_t cntr_info_2;
22642         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22643         ndr->depth++;
22644         if (flags & NDR_SET_VALUES) {
22645                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22646         }
22647         if (flags & NDR_IN) {
22648                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22649                 ndr->depth++;
22650                 ndr_print_ptr(ndr, "servername", r->in.servername);
22651                 ndr->depth++;
22652                 if (r->in.servername) {
22653                         ndr_print_string(ndr, "servername", r->in.servername);
22654                 }
22655                 ndr->depth--;
22656                 ndr_print_uint32(ndr, "level", r->in.level);
22657                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22658                 ndr->depth++;
22659                 if (r->in.buffer) {
22660                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22661                 }
22662                 ndr->depth--;
22663                 ndr_print_uint32(ndr, "offered", r->in.offered);
22664                 ndr->depth--;
22665         }
22666         if (flags & NDR_OUT) {
22667                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22668                 ndr->depth++;
22669                 ndr_print_ptr(ndr, "count", r->out.count);
22670                 ndr->depth++;
22671                 ndr_print_uint32(ndr, "count", *r->out.count);
22672                 ndr->depth--;
22673                 ndr_print_ptr(ndr, "info", r->out.info);
22674                 ndr->depth++;
22675                 ndr_print_ptr(ndr, "info", *r->out.info);
22676                 ndr->depth++;
22677                 if (*r->out.info) {
22678                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22679                         ndr->depth++;
22680                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22681                                 char *idx_2=NULL;
22682                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22683                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22684                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22685                                         free(idx_2);
22686                                 }
22687                         }
22688                         ndr->depth--;
22689                 }
22690                 ndr->depth--;
22691                 ndr->depth--;
22692                 ndr_print_ptr(ndr, "needed", r->out.needed);
22693                 ndr->depth++;
22694                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22695                 ndr->depth--;
22696                 ndr_print_WERROR(ndr, "result", r->out.result);
22697                 ndr->depth--;
22698         }
22699         ndr->depth--;
22700 }
22701
22702 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22703 {
22704         if (flags & NDR_IN) {
22705                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22706                 if (r->in.servername) {
22707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22709                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22710                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22711                 }
22712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22714                 if (r->in.buffer) {
22715                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22716                 }
22717                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22718         }
22719         if (flags & NDR_OUT) {
22720                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22721                 if (r->out.info) {
22722                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22723                 }
22724                 if (r->out.needed == NULL) {
22725                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22726                 }
22727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22728                 if (r->out.count == NULL) {
22729                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22730                 }
22731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22732                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22733         }
22734         return NDR_ERR_SUCCESS;
22735 }
22736
22737 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22738 {
22739         uint32_t _ptr_servername;
22740         uint32_t _ptr_buffer;
22741         uint32_t _ptr_info;
22742         TALLOC_CTX *_mem_save_servername_0;
22743         TALLOC_CTX *_mem_save_buffer_0;
22744         TALLOC_CTX *_mem_save_info_0;
22745         TALLOC_CTX *_mem_save_needed_0;
22746         TALLOC_CTX *_mem_save_count_0;
22747         if (flags & NDR_IN) {
22748                 ZERO_STRUCT(r->out);
22749
22750                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22751                 if (_ptr_servername) {
22752                         NDR_PULL_ALLOC(ndr, r->in.servername);
22753                 } else {
22754                         r->in.servername = NULL;
22755                 }
22756                 if (r->in.servername) {
22757                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22758                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22759                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22760                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22761                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22762                                 return 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));
22763                         }
22764                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22765                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22767                 }
22768                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22770                 if (_ptr_buffer) {
22771                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22772                 } else {
22773                         r->in.buffer = NULL;
22774                 }
22775                 if (r->in.buffer) {
22776                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22777                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22778                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22779                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22780                 }
22781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22782                 NDR_PULL_ALLOC(ndr, r->out.needed);
22783                 ZERO_STRUCTP(r->out.needed);
22784                 NDR_PULL_ALLOC(ndr, r->out.count);
22785                 ZERO_STRUCTP(r->out.count);
22786         }
22787         if (flags & NDR_OUT) {
22788                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22789                 if (_ptr_info) {
22790                         NDR_PULL_ALLOC(ndr, r->out.info);
22791                 } else {
22792                         r->out.info = NULL;
22793                 }
22794                 if (r->out.info) {
22795                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22796                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22797                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22798                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22799                 }
22800                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22801                         NDR_PULL_ALLOC(ndr, r->out.needed);
22802                 }
22803                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22804                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22806                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22807                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22808                         NDR_PULL_ALLOC(ndr, r->out.count);
22809                 }
22810                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22811                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22812                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22813                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22814                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22815         }
22816         return NDR_ERR_SUCCESS;
22817 }
22818
22819 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
22820 {
22821         uint32_t cntr_info_0;
22822         if (flags & NDR_IN) {
22823                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22825         }
22826         if (flags & NDR_OUT) {
22827                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22828                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22829                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22830                 }
22831                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22832                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22833                 }
22834         }
22835         return NDR_ERR_SUCCESS;
22836 }
22837
22838 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
22839 {
22840         uint32_t cntr_info_0;
22841         TALLOC_CTX *_mem_save_info_0;
22842         if (flags & NDR_IN) {
22843                 ZERO_STRUCT(r->out);
22844
22845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22847         }
22848         if (flags & NDR_OUT) {
22849                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22850                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22851                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22852                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22853                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22854                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22855                 }
22856                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22857                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22858                 }
22859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22860         }
22861         return NDR_ERR_SUCCESS;
22862 }
22863
22864 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
22865 {
22866         uint32_t cntr_info_2;
22867         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
22868         ndr->depth++;
22869         if (flags & NDR_SET_VALUES) {
22870                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22871         }
22872         if (flags & NDR_IN) {
22873                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
22874                 ndr->depth++;
22875                 ndr_print_ptr(ndr, "servername", r->in.servername);
22876                 ndr->depth++;
22877                 if (r->in.servername) {
22878                         ndr_print_string(ndr, "servername", r->in.servername);
22879                 }
22880                 ndr->depth--;
22881                 ndr_print_uint32(ndr, "level", r->in.level);
22882                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22883                 ndr->depth++;
22884                 if (r->in.buffer) {
22885                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22886                 }
22887                 ndr->depth--;
22888                 ndr_print_uint32(ndr, "offered", r->in.offered);
22889                 ndr->depth--;
22890         }
22891         if (flags & NDR_OUT) {
22892                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
22893                 ndr->depth++;
22894                 ndr_print_ptr(ndr, "count", r->out.count);
22895                 ndr->depth++;
22896                 ndr_print_uint32(ndr, "count", *r->out.count);
22897                 ndr->depth--;
22898                 ndr_print_ptr(ndr, "info", r->out.info);
22899                 ndr->depth++;
22900                 ndr_print_ptr(ndr, "info", *r->out.info);
22901                 ndr->depth++;
22902                 if (*r->out.info) {
22903                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22904                         ndr->depth++;
22905                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22906                                 char *idx_2=NULL;
22907                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22908                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22909                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22910                                         free(idx_2);
22911                                 }
22912                         }
22913                         ndr->depth--;
22914                 }
22915                 ndr->depth--;
22916                 ndr->depth--;
22917                 ndr_print_ptr(ndr, "needed", r->out.needed);
22918                 ndr->depth++;
22919                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22920                 ndr->depth--;
22921                 ndr_print_WERROR(ndr, "result", r->out.result);
22922                 ndr->depth--;
22923         }
22924         ndr->depth--;
22925 }
22926
22927 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
22928 {
22929         if (flags & NDR_IN) {
22930                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
22931                 if (r->in.server_name) {
22932                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
22935                         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));
22936                 }
22937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
22938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22939                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
22941                 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));
22942         }
22943         if (flags & NDR_OUT) {
22944                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22945         }
22946         return NDR_ERR_SUCCESS;
22947 }
22948
22949 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
22950 {
22951         uint32_t _ptr_server_name;
22952         TALLOC_CTX *_mem_save_server_name_0;
22953         if (flags & NDR_IN) {
22954                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
22955                 if (_ptr_server_name) {
22956                         NDR_PULL_ALLOC(ndr, r->in.server_name);
22957                 } else {
22958                         r->in.server_name = NULL;
22959                 }
22960                 if (r->in.server_name) {
22961                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
22962                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
22963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
22964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
22965                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
22966                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.server_name), ndr_get_array_length(ndr, &r->in.server_name));
22967                         }
22968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
22969                         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));
22970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
22971                 }
22972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
22973                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
22974                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
22975                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
22976                         return 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));
22977                 }
22978                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
22979                 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));
22980         }
22981         if (flags & NDR_OUT) {
22982                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22983         }
22984         return NDR_ERR_SUCCESS;
22985 }
22986
22987 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
22988 {
22989         ndr_print_struct(ndr, name, "spoolss_AddPort");
22990         ndr->depth++;
22991         if (flags & NDR_SET_VALUES) {
22992                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22993         }
22994         if (flags & NDR_IN) {
22995                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
22996                 ndr->depth++;
22997                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
22998                 ndr->depth++;
22999                 if (r->in.server_name) {
23000                         ndr_print_string(ndr, "server_name", r->in.server_name);
23001                 }
23002                 ndr->depth--;
23003                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23004                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23005                 ndr->depth--;
23006         }
23007         if (flags & NDR_OUT) {
23008                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23009                 ndr->depth++;
23010                 ndr_print_WERROR(ndr, "result", r->out.result);
23011                 ndr->depth--;
23012         }
23013         ndr->depth--;
23014 }
23015
23016 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23017 {
23018         if (flags & NDR_IN) {
23019         }
23020         if (flags & NDR_OUT) {
23021                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23022         }
23023         return NDR_ERR_SUCCESS;
23024 }
23025
23026 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23027 {
23028         if (flags & NDR_IN) {
23029         }
23030         if (flags & NDR_OUT) {
23031                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23032         }
23033         return NDR_ERR_SUCCESS;
23034 }
23035
23036 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23037 {
23038         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23039         ndr->depth++;
23040         if (flags & NDR_SET_VALUES) {
23041                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23042         }
23043         if (flags & NDR_IN) {
23044                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23045                 ndr->depth++;
23046                 ndr->depth--;
23047         }
23048         if (flags & NDR_OUT) {
23049                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23050                 ndr->depth++;
23051                 ndr_print_WERROR(ndr, "result", r->out.result);
23052                 ndr->depth--;
23053         }
23054         ndr->depth--;
23055 }
23056
23057 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23058 {
23059         if (flags & NDR_IN) {
23060         }
23061         if (flags & NDR_OUT) {
23062                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23063         }
23064         return NDR_ERR_SUCCESS;
23065 }
23066
23067 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23068 {
23069         if (flags & NDR_IN) {
23070         }
23071         if (flags & NDR_OUT) {
23072                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23073         }
23074         return NDR_ERR_SUCCESS;
23075 }
23076
23077 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23078 {
23079         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23080         ndr->depth++;
23081         if (flags & NDR_SET_VALUES) {
23082                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23083         }
23084         if (flags & NDR_IN) {
23085                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23086                 ndr->depth++;
23087                 ndr->depth--;
23088         }
23089         if (flags & NDR_OUT) {
23090                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23091                 ndr->depth++;
23092                 ndr_print_WERROR(ndr, "result", r->out.result);
23093                 ndr->depth--;
23094         }
23095         ndr->depth--;
23096 }
23097
23098 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23099 {
23100         if (flags & NDR_IN) {
23101         }
23102         if (flags & NDR_OUT) {
23103                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23104         }
23105         return NDR_ERR_SUCCESS;
23106 }
23107
23108 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23109 {
23110         if (flags & NDR_IN) {
23111         }
23112         if (flags & NDR_OUT) {
23113                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23114         }
23115         return NDR_ERR_SUCCESS;
23116 }
23117
23118 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23119 {
23120         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23121         ndr->depth++;
23122         if (flags & NDR_SET_VALUES) {
23123                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23124         }
23125         if (flags & NDR_IN) {
23126                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23127                 ndr->depth++;
23128                 ndr->depth--;
23129         }
23130         if (flags & NDR_OUT) {
23131                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23132                 ndr->depth++;
23133                 ndr_print_WERROR(ndr, "result", r->out.result);
23134                 ndr->depth--;
23135         }
23136         ndr->depth--;
23137 }
23138
23139 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23140 {
23141         if (flags & NDR_IN) {
23142         }
23143         if (flags & NDR_OUT) {
23144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23145         }
23146         return NDR_ERR_SUCCESS;
23147 }
23148
23149 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23150 {
23151         if (flags & NDR_IN) {
23152         }
23153         if (flags & NDR_OUT) {
23154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23155         }
23156         return NDR_ERR_SUCCESS;
23157 }
23158
23159 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23160 {
23161         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23162         ndr->depth++;
23163         if (flags & NDR_SET_VALUES) {
23164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23165         }
23166         if (flags & NDR_IN) {
23167                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23168                 ndr->depth++;
23169                 ndr->depth--;
23170         }
23171         if (flags & NDR_OUT) {
23172                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23173                 ndr->depth++;
23174                 ndr_print_WERROR(ndr, "result", r->out.result);
23175                 ndr->depth--;
23176         }
23177         ndr->depth--;
23178 }
23179
23180 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23181 {
23182         if (flags & NDR_IN) {
23183         }
23184         if (flags & NDR_OUT) {
23185                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23186         }
23187         return NDR_ERR_SUCCESS;
23188 }
23189
23190 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23191 {
23192         if (flags & NDR_IN) {
23193         }
23194         if (flags & NDR_OUT) {
23195                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23196         }
23197         return NDR_ERR_SUCCESS;
23198 }
23199
23200 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23201 {
23202         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23203         ndr->depth++;
23204         if (flags & NDR_SET_VALUES) {
23205                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23206         }
23207         if (flags & NDR_IN) {
23208                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23209                 ndr->depth++;
23210                 ndr->depth--;
23211         }
23212         if (flags & NDR_OUT) {
23213                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23214                 ndr->depth++;
23215                 ndr_print_WERROR(ndr, "result", r->out.result);
23216                 ndr->depth--;
23217         }
23218         ndr->depth--;
23219 }
23220
23221 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23222 {
23223         if (flags & NDR_IN) {
23224         }
23225         if (flags & NDR_OUT) {
23226                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23227         }
23228         return NDR_ERR_SUCCESS;
23229 }
23230
23231 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23232 {
23233         if (flags & NDR_IN) {
23234         }
23235         if (flags & NDR_OUT) {
23236                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23237         }
23238         return NDR_ERR_SUCCESS;
23239 }
23240
23241 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23242 {
23243         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23244         ndr->depth++;
23245         if (flags & NDR_SET_VALUES) {
23246                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23247         }
23248         if (flags & NDR_IN) {
23249                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23250                 ndr->depth++;
23251                 ndr->depth--;
23252         }
23253         if (flags & NDR_OUT) {
23254                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23255                 ndr->depth++;
23256                 ndr_print_WERROR(ndr, "result", r->out.result);
23257                 ndr->depth--;
23258         }
23259         ndr->depth--;
23260 }
23261
23262 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23263 {
23264         if (flags & NDR_IN) {
23265         }
23266         if (flags & NDR_OUT) {
23267                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23268         }
23269         return NDR_ERR_SUCCESS;
23270 }
23271
23272 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23273 {
23274         if (flags & NDR_IN) {
23275         }
23276         if (flags & NDR_OUT) {
23277                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23278         }
23279         return NDR_ERR_SUCCESS;
23280 }
23281
23282 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23283 {
23284         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23285         ndr->depth++;
23286         if (flags & NDR_SET_VALUES) {
23287                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23288         }
23289         if (flags & NDR_IN) {
23290                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23291                 ndr->depth++;
23292                 ndr->depth--;
23293         }
23294         if (flags & NDR_OUT) {
23295                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23296                 ndr->depth++;
23297                 ndr_print_WERROR(ndr, "result", r->out.result);
23298                 ndr->depth--;
23299         }
23300         ndr->depth--;
23301 }
23302
23303 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23304 {
23305         if (flags & NDR_IN) {
23306         }
23307         if (flags & NDR_OUT) {
23308                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23309         }
23310         return NDR_ERR_SUCCESS;
23311 }
23312
23313 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23314 {
23315         if (flags & NDR_IN) {
23316         }
23317         if (flags & NDR_OUT) {
23318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23319         }
23320         return NDR_ERR_SUCCESS;
23321 }
23322
23323 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23324 {
23325         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23326         ndr->depth++;
23327         if (flags & NDR_SET_VALUES) {
23328                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23329         }
23330         if (flags & NDR_IN) {
23331                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23332                 ndr->depth++;
23333                 ndr->depth--;
23334         }
23335         if (flags & NDR_OUT) {
23336                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23337                 ndr->depth++;
23338                 ndr_print_WERROR(ndr, "result", r->out.result);
23339                 ndr->depth--;
23340         }
23341         ndr->depth--;
23342 }
23343
23344 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23345 {
23346         if (flags & NDR_IN) {
23347         }
23348         if (flags & NDR_OUT) {
23349                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23350         }
23351         return NDR_ERR_SUCCESS;
23352 }
23353
23354 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23355 {
23356         if (flags & NDR_IN) {
23357         }
23358         if (flags & NDR_OUT) {
23359                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23360         }
23361         return NDR_ERR_SUCCESS;
23362 }
23363
23364 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23365 {
23366         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23367         ndr->depth++;
23368         if (flags & NDR_SET_VALUES) {
23369                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23370         }
23371         if (flags & NDR_IN) {
23372                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23373                 ndr->depth++;
23374                 ndr->depth--;
23375         }
23376         if (flags & NDR_OUT) {
23377                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23378                 ndr->depth++;
23379                 ndr_print_WERROR(ndr, "result", r->out.result);
23380                 ndr->depth--;
23381         }
23382         ndr->depth--;
23383 }
23384
23385 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23386 {
23387         if (flags & NDR_IN) {
23388         }
23389         if (flags & NDR_OUT) {
23390                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23391         }
23392         return NDR_ERR_SUCCESS;
23393 }
23394
23395 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23396 {
23397         if (flags & NDR_IN) {
23398         }
23399         if (flags & NDR_OUT) {
23400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23401         }
23402         return NDR_ERR_SUCCESS;
23403 }
23404
23405 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23406 {
23407         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23408         ndr->depth++;
23409         if (flags & NDR_SET_VALUES) {
23410                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23411         }
23412         if (flags & NDR_IN) {
23413                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23414                 ndr->depth++;
23415                 ndr->depth--;
23416         }
23417         if (flags & NDR_OUT) {
23418                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23419                 ndr->depth++;
23420                 ndr_print_WERROR(ndr, "result", r->out.result);
23421                 ndr->depth--;
23422         }
23423         ndr->depth--;
23424 }
23425
23426 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23427 {
23428         if (flags & NDR_IN) {
23429         }
23430         if (flags & NDR_OUT) {
23431                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23432         }
23433         return NDR_ERR_SUCCESS;
23434 }
23435
23436 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23437 {
23438         if (flags & NDR_IN) {
23439         }
23440         if (flags & NDR_OUT) {
23441                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23442         }
23443         return NDR_ERR_SUCCESS;
23444 }
23445
23446 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23447 {
23448         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23449         ndr->depth++;
23450         if (flags & NDR_SET_VALUES) {
23451                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23452         }
23453         if (flags & NDR_IN) {
23454                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23455                 ndr->depth++;
23456                 ndr->depth--;
23457         }
23458         if (flags & NDR_OUT) {
23459                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23460                 ndr->depth++;
23461                 ndr_print_WERROR(ndr, "result", r->out.result);
23462                 ndr->depth--;
23463         }
23464         ndr->depth--;
23465 }
23466
23467 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23468 {
23469         if (flags & NDR_IN) {
23470         }
23471         if (flags & NDR_OUT) {
23472                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23473         }
23474         return NDR_ERR_SUCCESS;
23475 }
23476
23477 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23478 {
23479         if (flags & NDR_IN) {
23480         }
23481         if (flags & NDR_OUT) {
23482                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23483         }
23484         return NDR_ERR_SUCCESS;
23485 }
23486
23487 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23488 {
23489         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23490         ndr->depth++;
23491         if (flags & NDR_SET_VALUES) {
23492                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23493         }
23494         if (flags & NDR_IN) {
23495                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23496                 ndr->depth++;
23497                 ndr->depth--;
23498         }
23499         if (flags & NDR_OUT) {
23500                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23501                 ndr->depth++;
23502                 ndr_print_WERROR(ndr, "result", r->out.result);
23503                 ndr->depth--;
23504         }
23505         ndr->depth--;
23506 }
23507
23508 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23509 {
23510         if (flags & NDR_IN) {
23511         }
23512         if (flags & NDR_OUT) {
23513                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23514         }
23515         return NDR_ERR_SUCCESS;
23516 }
23517
23518 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23519 {
23520         if (flags & NDR_IN) {
23521         }
23522         if (flags & NDR_OUT) {
23523                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23524         }
23525         return NDR_ERR_SUCCESS;
23526 }
23527
23528 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23529 {
23530         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23531         ndr->depth++;
23532         if (flags & NDR_SET_VALUES) {
23533                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23534         }
23535         if (flags & NDR_IN) {
23536                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23537                 ndr->depth++;
23538                 ndr->depth--;
23539         }
23540         if (flags & NDR_OUT) {
23541                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23542                 ndr->depth++;
23543                 ndr_print_WERROR(ndr, "result", r->out.result);
23544                 ndr->depth--;
23545         }
23546         ndr->depth--;
23547 }
23548
23549 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23550 {
23551         if (flags & NDR_IN) {
23552                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23553                 if (r->in.servername) {
23554                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23555                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23556                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23557                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23558                 }
23559                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23560                 if (r->in.print_processor_name) {
23561                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23562                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23563                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23564                         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));
23565                 }
23566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23567                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23568                 if (r->in.buffer) {
23569                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23570                 }
23571                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23572         }
23573         if (flags & NDR_OUT) {
23574                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23575                 if (r->out.info) {
23576                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23577                 }
23578                 if (r->out.needed == NULL) {
23579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23580                 }
23581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23582                 if (r->out.count == NULL) {
23583                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23584                 }
23585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23586                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23587         }
23588         return NDR_ERR_SUCCESS;
23589 }
23590
23591 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23592 {
23593         uint32_t _ptr_servername;
23594         uint32_t _ptr_print_processor_name;
23595         uint32_t _ptr_buffer;
23596         uint32_t _ptr_info;
23597         TALLOC_CTX *_mem_save_servername_0;
23598         TALLOC_CTX *_mem_save_print_processor_name_0;
23599         TALLOC_CTX *_mem_save_buffer_0;
23600         TALLOC_CTX *_mem_save_info_0;
23601         TALLOC_CTX *_mem_save_needed_0;
23602         TALLOC_CTX *_mem_save_count_0;
23603         if (flags & NDR_IN) {
23604                 ZERO_STRUCT(r->out);
23605
23606                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23607                 if (_ptr_servername) {
23608                         NDR_PULL_ALLOC(ndr, r->in.servername);
23609                 } else {
23610                         r->in.servername = NULL;
23611                 }
23612                 if (r->in.servername) {
23613                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23614                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23615                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23616                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23617                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23618                                 return 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));
23619                         }
23620                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23621                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23622                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23623                 }
23624                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23625                 if (_ptr_print_processor_name) {
23626                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23627                 } else {
23628                         r->in.print_processor_name = NULL;
23629                 }
23630                 if (r->in.print_processor_name) {
23631                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23632                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23633                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23634                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23635                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23636                                 return 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));
23637                         }
23638                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23639                         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));
23640                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23641                 }
23642                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23643                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23644                 if (_ptr_buffer) {
23645                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23646                 } else {
23647                         r->in.buffer = NULL;
23648                 }
23649                 if (r->in.buffer) {
23650                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23651                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23652                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23653                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23654                 }
23655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23656                 NDR_PULL_ALLOC(ndr, r->out.needed);
23657                 ZERO_STRUCTP(r->out.needed);
23658                 NDR_PULL_ALLOC(ndr, r->out.count);
23659                 ZERO_STRUCTP(r->out.count);
23660         }
23661         if (flags & NDR_OUT) {
23662                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23663                 if (_ptr_info) {
23664                         NDR_PULL_ALLOC(ndr, r->out.info);
23665                 } else {
23666                         r->out.info = NULL;
23667                 }
23668                 if (r->out.info) {
23669                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23670                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23671                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23673                 }
23674                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23675                         NDR_PULL_ALLOC(ndr, r->out.needed);
23676                 }
23677                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23678                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23679                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23680                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23681                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23682                         NDR_PULL_ALLOC(ndr, r->out.count);
23683                 }
23684                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23685                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23687                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23688                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23689         }
23690         return NDR_ERR_SUCCESS;
23691 }
23692
23693 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
23694 {
23695         uint32_t cntr_info_0;
23696         if (flags & NDR_IN) {
23697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23699         }
23700         if (flags & NDR_OUT) {
23701                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23702                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23703                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23704                 }
23705                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23706                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23707                 }
23708         }
23709         return NDR_ERR_SUCCESS;
23710 }
23711
23712 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
23713 {
23714         uint32_t cntr_info_0;
23715         TALLOC_CTX *_mem_save_info_0;
23716         if (flags & NDR_IN) {
23717                 ZERO_STRUCT(r->out);
23718
23719                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23721         }
23722         if (flags & NDR_OUT) {
23723                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23724                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23725                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23726                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23727                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23728                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23729                 }
23730                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23731                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23732                 }
23733                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23734         }
23735         return NDR_ERR_SUCCESS;
23736 }
23737
23738 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23739 {
23740         uint32_t cntr_info_2;
23741         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23742         ndr->depth++;
23743         if (flags & NDR_SET_VALUES) {
23744                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23745         }
23746         if (flags & NDR_IN) {
23747                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23748                 ndr->depth++;
23749                 ndr_print_ptr(ndr, "servername", r->in.servername);
23750                 ndr->depth++;
23751                 if (r->in.servername) {
23752                         ndr_print_string(ndr, "servername", r->in.servername);
23753                 }
23754                 ndr->depth--;
23755                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
23756                 ndr->depth++;
23757                 if (r->in.print_processor_name) {
23758                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23759                 }
23760                 ndr->depth--;
23761                 ndr_print_uint32(ndr, "level", r->in.level);
23762                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23763                 ndr->depth++;
23764                 if (r->in.buffer) {
23765                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23766                 }
23767                 ndr->depth--;
23768                 ndr_print_uint32(ndr, "offered", r->in.offered);
23769                 ndr->depth--;
23770         }
23771         if (flags & NDR_OUT) {
23772                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23773                 ndr->depth++;
23774                 ndr_print_ptr(ndr, "count", r->out.count);
23775                 ndr->depth++;
23776                 ndr_print_uint32(ndr, "count", *r->out.count);
23777                 ndr->depth--;
23778                 ndr_print_ptr(ndr, "info", r->out.info);
23779                 ndr->depth++;
23780                 ndr_print_ptr(ndr, "info", *r->out.info);
23781                 ndr->depth++;
23782                 if (*r->out.info) {
23783                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23784                         ndr->depth++;
23785                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23786                                 char *idx_2=NULL;
23787                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23788                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23789                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23790                                         free(idx_2);
23791                                 }
23792                         }
23793                         ndr->depth--;
23794                 }
23795                 ndr->depth--;
23796                 ndr->depth--;
23797                 ndr_print_ptr(ndr, "needed", r->out.needed);
23798                 ndr->depth++;
23799                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23800                 ndr->depth--;
23801                 ndr_print_WERROR(ndr, "result", r->out.result);
23802                 ndr->depth--;
23803         }
23804         ndr->depth--;
23805 }
23806
23807 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
23808 {
23809         if (flags & NDR_IN) {
23810                 if (r->in.handle == NULL) {
23811                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23812                 }
23813                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
23815                 if (r->in.data_type) {
23816                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23817                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23818                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23819                         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));
23820                 }
23821                 if (r->in.devmode_ctr == NULL) {
23822                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23823                 }
23824                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23825         }
23826         if (flags & NDR_OUT) {
23827                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23828         }
23829         return NDR_ERR_SUCCESS;
23830 }
23831
23832 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
23833 {
23834         uint32_t _ptr_data_type;
23835         TALLOC_CTX *_mem_save_handle_0;
23836         TALLOC_CTX *_mem_save_data_type_0;
23837         TALLOC_CTX *_mem_save_devmode_ctr_0;
23838         if (flags & NDR_IN) {
23839                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23840                         NDR_PULL_ALLOC(ndr, r->in.handle);
23841                 }
23842                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23843                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23844                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23845                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
23847                 if (_ptr_data_type) {
23848                         NDR_PULL_ALLOC(ndr, r->in.data_type);
23849                 } else {
23850                         r->in.data_type = NULL;
23851                 }
23852                 if (r->in.data_type) {
23853                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23854                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
23855                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
23856                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
23857                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
23858                                 return 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));
23859                         }
23860                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
23861                         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));
23862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
23863                 }
23864                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23865                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23866                 }
23867                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23868                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23869                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23870                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23871         }
23872         if (flags & NDR_OUT) {
23873                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23874         }
23875         return NDR_ERR_SUCCESS;
23876 }
23877
23878 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
23879 {
23880         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
23881         ndr->depth++;
23882         if (flags & NDR_SET_VALUES) {
23883                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23884         }
23885         if (flags & NDR_IN) {
23886                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
23887                 ndr->depth++;
23888                 ndr_print_ptr(ndr, "handle", r->in.handle);
23889                 ndr->depth++;
23890                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23891                 ndr->depth--;
23892                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
23893                 ndr->depth++;
23894                 if (r->in.data_type) {
23895                         ndr_print_string(ndr, "data_type", r->in.data_type);
23896                 }
23897                 ndr->depth--;
23898                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23899                 ndr->depth++;
23900                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23901                 ndr->depth--;
23902                 ndr->depth--;
23903         }
23904         if (flags & NDR_OUT) {
23905                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
23906                 ndr->depth++;
23907                 ndr_print_WERROR(ndr, "result", r->out.result);
23908                 ndr->depth--;
23909         }
23910         ndr->depth--;
23911 }
23912
23913 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
23914 {
23915         if (flags & NDR_IN) {
23916                 if (r->in.handle == NULL) {
23917                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23918                 }
23919                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23920                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
23921                 if (r->in.architecture) {
23922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23924                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23925                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23926                 }
23927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23928                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23929                 if (r->in.buffer) {
23930                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23931                 }
23932                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
23934                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
23935         }
23936         if (flags & NDR_OUT) {
23937                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23938                 if (r->out.info) {
23939                         {
23940                                 struct ndr_push *_ndr_info;
23941                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
23942                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
23943                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
23944                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
23945                         }
23946                 }
23947                 if (r->out.needed == NULL) {
23948                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23949                 }
23950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23951                 if (r->out.server_major_version == NULL) {
23952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23953                 }
23954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
23955                 if (r->out.server_minor_version == NULL) {
23956                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23957                 }
23958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
23959                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23960         }
23961         return NDR_ERR_SUCCESS;
23962 }
23963
23964 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
23965 {
23966         uint32_t _ptr_architecture;
23967         uint32_t _ptr_buffer;
23968         uint32_t _ptr_info;
23969         TALLOC_CTX *_mem_save_handle_0;
23970         TALLOC_CTX *_mem_save_architecture_0;
23971         TALLOC_CTX *_mem_save_buffer_0;
23972         TALLOC_CTX *_mem_save_info_0;
23973         TALLOC_CTX *_mem_save_needed_0;
23974         TALLOC_CTX *_mem_save_server_major_version_0;
23975         TALLOC_CTX *_mem_save_server_minor_version_0;
23976         if (flags & NDR_IN) {
23977                 ZERO_STRUCT(r->out);
23978
23979                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23980                         NDR_PULL_ALLOC(ndr, r->in.handle);
23981                 }
23982                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23983                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23984                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23985                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23986                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
23987                 if (_ptr_architecture) {
23988                         NDR_PULL_ALLOC(ndr, r->in.architecture);
23989                 } else {
23990                         r->in.architecture = NULL;
23991                 }
23992                 if (r->in.architecture) {
23993                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
23994                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
23995                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
23996                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
23997                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
23998                                 return 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));
23999                         }
24000                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24001                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24002                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24003                 }
24004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24005                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24006                 if (_ptr_buffer) {
24007                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24008                 } else {
24009                         r->in.buffer = NULL;
24010                 }
24011                 if (r->in.buffer) {
24012                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24013                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24014                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24015                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24016                 }
24017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24018                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24019                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24020                 NDR_PULL_ALLOC(ndr, r->out.needed);
24021                 ZERO_STRUCTP(r->out.needed);
24022                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24023                 ZERO_STRUCTP(r->out.server_major_version);
24024                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24025                 ZERO_STRUCTP(r->out.server_minor_version);
24026         }
24027         if (flags & NDR_OUT) {
24028                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24029                 if (_ptr_info) {
24030                         NDR_PULL_ALLOC(ndr, r->out.info);
24031                 } else {
24032                         r->out.info = NULL;
24033                 }
24034                 if (r->out.info) {
24035                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24036                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24037                         {
24038                                 struct ndr_pull *_ndr_info;
24039                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24040                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24041                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24042                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24043                         }
24044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24045                 }
24046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24047                         NDR_PULL_ALLOC(ndr, r->out.needed);
24048                 }
24049                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24050                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24053                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24054                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24055                 }
24056                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24057                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24058                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24059                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24060                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24061                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24062                 }
24063                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24064                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24066                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24067                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24068         }
24069         return NDR_ERR_SUCCESS;
24070 }
24071
24072 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24073 {
24074         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24075         ndr->depth++;
24076         if (flags & NDR_SET_VALUES) {
24077                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24078         }
24079         if (flags & NDR_IN) {
24080                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24081                 ndr->depth++;
24082                 ndr_print_ptr(ndr, "handle", r->in.handle);
24083                 ndr->depth++;
24084                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24085                 ndr->depth--;
24086                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24087                 ndr->depth++;
24088                 if (r->in.architecture) {
24089                         ndr_print_string(ndr, "architecture", r->in.architecture);
24090                 }
24091                 ndr->depth--;
24092                 ndr_print_uint32(ndr, "level", r->in.level);
24093                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24094                 ndr->depth++;
24095                 if (r->in.buffer) {
24096                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24097                 }
24098                 ndr->depth--;
24099                 ndr_print_uint32(ndr, "offered", r->in.offered);
24100                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24101                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24102                 ndr->depth--;
24103         }
24104         if (flags & NDR_OUT) {
24105                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24106                 ndr->depth++;
24107                 ndr_print_ptr(ndr, "info", r->out.info);
24108                 ndr->depth++;
24109                 if (r->out.info) {
24110                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24111                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24112                 }
24113                 ndr->depth--;
24114                 ndr_print_ptr(ndr, "needed", r->out.needed);
24115                 ndr->depth++;
24116                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24117                 ndr->depth--;
24118                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24119                 ndr->depth++;
24120                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24121                 ndr->depth--;
24122                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24123                 ndr->depth++;
24124                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24125                 ndr->depth--;
24126                 ndr_print_WERROR(ndr, "result", r->out.result);
24127                 ndr->depth--;
24128         }
24129         ndr->depth--;
24130 }
24131
24132 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24133 {
24134         if (flags & NDR_IN) {
24135         }
24136         if (flags & NDR_OUT) {
24137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24138         }
24139         return NDR_ERR_SUCCESS;
24140 }
24141
24142 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24143 {
24144         if (flags & NDR_IN) {
24145         }
24146         if (flags & NDR_OUT) {
24147                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24148         }
24149         return NDR_ERR_SUCCESS;
24150 }
24151
24152 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24153 {
24154         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24155         ndr->depth++;
24156         if (flags & NDR_SET_VALUES) {
24157                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24158         }
24159         if (flags & NDR_IN) {
24160                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24161                 ndr->depth++;
24162                 ndr->depth--;
24163         }
24164         if (flags & NDR_OUT) {
24165                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24166                 ndr->depth++;
24167                 ndr_print_WERROR(ndr, "result", r->out.result);
24168                 ndr->depth--;
24169         }
24170         ndr->depth--;
24171 }
24172
24173 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24174 {
24175         if (flags & NDR_IN) {
24176         }
24177         if (flags & NDR_OUT) {
24178                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24179         }
24180         return NDR_ERR_SUCCESS;
24181 }
24182
24183 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24184 {
24185         if (flags & NDR_IN) {
24186         }
24187         if (flags & NDR_OUT) {
24188                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24189         }
24190         return NDR_ERR_SUCCESS;
24191 }
24192
24193 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24194 {
24195         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24196         ndr->depth++;
24197         if (flags & NDR_SET_VALUES) {
24198                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24199         }
24200         if (flags & NDR_IN) {
24201                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24202                 ndr->depth++;
24203                 ndr->depth--;
24204         }
24205         if (flags & NDR_OUT) {
24206                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24207                 ndr->depth++;
24208                 ndr_print_WERROR(ndr, "result", r->out.result);
24209                 ndr->depth--;
24210         }
24211         ndr->depth--;
24212 }
24213
24214 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24215 {
24216         if (flags & NDR_IN) {
24217                 if (r->in.handle == NULL) {
24218                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24219                 }
24220                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24221         }
24222         if (flags & NDR_OUT) {
24223                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24224         }
24225         return NDR_ERR_SUCCESS;
24226 }
24227
24228 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24229 {
24230         TALLOC_CTX *_mem_save_handle_0;
24231         if (flags & NDR_IN) {
24232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24233                         NDR_PULL_ALLOC(ndr, r->in.handle);
24234                 }
24235                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24236                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24237                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24239         }
24240         if (flags & NDR_OUT) {
24241                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24242         }
24243         return NDR_ERR_SUCCESS;
24244 }
24245
24246 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24247 {
24248         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24249         ndr->depth++;
24250         if (flags & NDR_SET_VALUES) {
24251                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24252         }
24253         if (flags & NDR_IN) {
24254                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24255                 ndr->depth++;
24256                 ndr_print_ptr(ndr, "handle", r->in.handle);
24257                 ndr->depth++;
24258                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24259                 ndr->depth--;
24260                 ndr->depth--;
24261         }
24262         if (flags & NDR_OUT) {
24263                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24264                 ndr->depth++;
24265                 ndr_print_WERROR(ndr, "result", r->out.result);
24266                 ndr->depth--;
24267         }
24268         ndr->depth--;
24269 }
24270
24271 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24272 {
24273         if (flags & NDR_IN) {
24274         }
24275         if (flags & NDR_OUT) {
24276                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24277         }
24278         return NDR_ERR_SUCCESS;
24279 }
24280
24281 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24282 {
24283         if (flags & NDR_IN) {
24284         }
24285         if (flags & NDR_OUT) {
24286                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24287         }
24288         return NDR_ERR_SUCCESS;
24289 }
24290
24291 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24292 {
24293         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24294         ndr->depth++;
24295         if (flags & NDR_SET_VALUES) {
24296                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24297         }
24298         if (flags & NDR_IN) {
24299                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24300                 ndr->depth++;
24301                 ndr->depth--;
24302         }
24303         if (flags & NDR_OUT) {
24304                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24305                 ndr->depth++;
24306                 ndr_print_WERROR(ndr, "result", r->out.result);
24307                 ndr->depth--;
24308         }
24309         ndr->depth--;
24310 }
24311
24312 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24313 {
24314         if (flags & NDR_IN) {
24315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24318                 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));
24319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24320                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24323                 if (r->in.buffer) {
24324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24325                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24326                 }
24327         }
24328         if (flags & NDR_OUT) {
24329                 if (r->out.handle == NULL) {
24330                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24331                 }
24332                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24334         }
24335         return NDR_ERR_SUCCESS;
24336 }
24337
24338 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24339 {
24340         uint32_t _ptr_buffer;
24341         TALLOC_CTX *_mem_save_buffer_0;
24342         TALLOC_CTX *_mem_save_handle_0;
24343         if (flags & NDR_IN) {
24344                 ZERO_STRUCT(r->out);
24345
24346                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24347                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24348                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24349                         return 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));
24350                 }
24351                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24352                 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));
24353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24354                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24356                 if (r->in.bufsize > 512) {
24357                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24358                 }
24359                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24360                 if (_ptr_buffer) {
24361                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24362                 } else {
24363                         r->in.buffer = NULL;
24364                 }
24365                 if (r->in.buffer) {
24366                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24367                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24368                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24369                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24370                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24372                 }
24373                 NDR_PULL_ALLOC(ndr, r->out.handle);
24374                 ZERO_STRUCTP(r->out.handle);
24375                 if (r->in.buffer) {
24376                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24377                 }
24378         }
24379         if (flags & NDR_OUT) {
24380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24381                         NDR_PULL_ALLOC(ndr, r->out.handle);
24382                 }
24383                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24384                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24385                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24387                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24388         }
24389         return NDR_ERR_SUCCESS;
24390 }
24391
24392 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24393 {
24394         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24395         ndr->depth++;
24396         if (flags & NDR_SET_VALUES) {
24397                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24398         }
24399         if (flags & NDR_IN) {
24400                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24401                 ndr->depth++;
24402                 ndr_print_string(ndr, "server_name", r->in.server_name);
24403                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24404                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24405                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24406                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24407                 ndr->depth++;
24408                 if (r->in.buffer) {
24409                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24410                 }
24411                 ndr->depth--;
24412                 ndr->depth--;
24413         }
24414         if (flags & NDR_OUT) {
24415                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24416                 ndr->depth++;
24417                 ndr_print_ptr(ndr, "handle", r->out.handle);
24418                 ndr->depth++;
24419                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24420                 ndr->depth--;
24421                 ndr_print_WERROR(ndr, "result", r->out.result);
24422                 ndr->depth--;
24423         }
24424         ndr->depth--;
24425 }
24426
24427 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24428 {
24429         if (flags & NDR_IN) {
24430                 if (r->in.handle == NULL) {
24431                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24432                 }
24433                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24434                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24436                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24437                 if (r->in.buffer) {
24438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24439                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24440                 }
24441         }
24442         if (flags & NDR_OUT) {
24443                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24444         }
24445         return NDR_ERR_SUCCESS;
24446 }
24447
24448 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24449 {
24450         uint32_t _ptr_buffer;
24451         TALLOC_CTX *_mem_save_handle_0;
24452         TALLOC_CTX *_mem_save_buffer_0;
24453         if (flags & NDR_IN) {
24454                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24455                         NDR_PULL_ALLOC(ndr, r->in.handle);
24456                 }
24457                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24458                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24459                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24460                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24461                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24462                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24463                 if (r->in.bufsize > 512) {
24464                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24465                 }
24466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24467                 if (_ptr_buffer) {
24468                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24469                 } else {
24470                         r->in.buffer = NULL;
24471                 }
24472                 if (r->in.buffer) {
24473                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24474                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24475                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24476                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24477                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24478                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24479                 }
24480                 if (r->in.buffer) {
24481                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24482                 }
24483         }
24484         if (flags & NDR_OUT) {
24485                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24486         }
24487         return NDR_ERR_SUCCESS;
24488 }
24489
24490 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24491 {
24492         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24493         ndr->depth++;
24494         if (flags & NDR_SET_VALUES) {
24495                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24496         }
24497         if (flags & NDR_IN) {
24498                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24499                 ndr->depth++;
24500                 ndr_print_ptr(ndr, "handle", r->in.handle);
24501                 ndr->depth++;
24502                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24503                 ndr->depth--;
24504                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24505                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24506                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24507                 ndr->depth++;
24508                 if (r->in.buffer) {
24509                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24510                 }
24511                 ndr->depth--;
24512                 ndr->depth--;
24513         }
24514         if (flags & NDR_OUT) {
24515                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24516                 ndr->depth++;
24517                 ndr_print_WERROR(ndr, "result", r->out.result);
24518                 ndr->depth--;
24519         }
24520         ndr->depth--;
24521 }
24522
24523 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24524 {
24525         if (flags & NDR_IN) {
24526                 if (r->in.handle == NULL) {
24527                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24528                 }
24529                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24530         }
24531         if (flags & NDR_OUT) {
24532                 if (r->out.handle == NULL) {
24533                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24534                 }
24535                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24536                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24537         }
24538         return NDR_ERR_SUCCESS;
24539 }
24540
24541 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24542 {
24543         TALLOC_CTX *_mem_save_handle_0;
24544         if (flags & NDR_IN) {
24545                 ZERO_STRUCT(r->out);
24546
24547                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24548                         NDR_PULL_ALLOC(ndr, r->in.handle);
24549                 }
24550                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24551                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24552                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24553                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24554                 NDR_PULL_ALLOC(ndr, r->out.handle);
24555                 *r->out.handle = *r->in.handle;
24556         }
24557         if (flags & NDR_OUT) {
24558                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24559                         NDR_PULL_ALLOC(ndr, r->out.handle);
24560                 }
24561                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24562                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24563                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24564                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24565                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24566         }
24567         return NDR_ERR_SUCCESS;
24568 }
24569
24570 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24571 {
24572         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24573         ndr->depth++;
24574         if (flags & NDR_SET_VALUES) {
24575                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24576         }
24577         if (flags & NDR_IN) {
24578                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24579                 ndr->depth++;
24580                 ndr_print_ptr(ndr, "handle", r->in.handle);
24581                 ndr->depth++;
24582                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24583                 ndr->depth--;
24584                 ndr->depth--;
24585         }
24586         if (flags & NDR_OUT) {
24587                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24588                 ndr->depth++;
24589                 ndr_print_ptr(ndr, "handle", r->out.handle);
24590                 ndr->depth++;
24591                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24592                 ndr->depth--;
24593                 ndr_print_WERROR(ndr, "result", r->out.result);
24594                 ndr->depth--;
24595         }
24596         ndr->depth--;
24597 }
24598
24599 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24600 {
24601         if (flags & NDR_IN) {
24602         }
24603         if (flags & NDR_OUT) {
24604                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24605         }
24606         return NDR_ERR_SUCCESS;
24607 }
24608
24609 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24610 {
24611         if (flags & NDR_IN) {
24612         }
24613         if (flags & NDR_OUT) {
24614                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24615         }
24616         return NDR_ERR_SUCCESS;
24617 }
24618
24619 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24620 {
24621         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24622         ndr->depth++;
24623         if (flags & NDR_SET_VALUES) {
24624                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24625         }
24626         if (flags & NDR_IN) {
24627                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24628                 ndr->depth++;
24629                 ndr->depth--;
24630         }
24631         if (flags & NDR_OUT) {
24632                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24633                 ndr->depth++;
24634                 ndr_print_WERROR(ndr, "result", r->out.result);
24635                 ndr->depth--;
24636         }
24637         ndr->depth--;
24638 }
24639
24640 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24641 {
24642         if (flags & NDR_IN) {
24643         }
24644         if (flags & NDR_OUT) {
24645                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24646         }
24647         return NDR_ERR_SUCCESS;
24648 }
24649
24650 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24651 {
24652         if (flags & NDR_IN) {
24653         }
24654         if (flags & NDR_OUT) {
24655                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24656         }
24657         return NDR_ERR_SUCCESS;
24658 }
24659
24660 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24661 {
24662         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24663         ndr->depth++;
24664         if (flags & NDR_SET_VALUES) {
24665                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24666         }
24667         if (flags & NDR_IN) {
24668                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24669                 ndr->depth++;
24670                 ndr->depth--;
24671         }
24672         if (flags & NDR_OUT) {
24673                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24674                 ndr->depth++;
24675                 ndr_print_WERROR(ndr, "result", r->out.result);
24676                 ndr->depth--;
24677         }
24678         ndr->depth--;
24679 }
24680
24681 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24682 {
24683         if (flags & NDR_IN) {
24684         }
24685         if (flags & NDR_OUT) {
24686                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24687         }
24688         return NDR_ERR_SUCCESS;
24689 }
24690
24691 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24692 {
24693         if (flags & NDR_IN) {
24694         }
24695         if (flags & NDR_OUT) {
24696                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24697         }
24698         return NDR_ERR_SUCCESS;
24699 }
24700
24701 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24702 {
24703         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24704         ndr->depth++;
24705         if (flags & NDR_SET_VALUES) {
24706                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24707         }
24708         if (flags & NDR_IN) {
24709                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24710                 ndr->depth++;
24711                 ndr->depth--;
24712         }
24713         if (flags & NDR_OUT) {
24714                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24715                 ndr->depth++;
24716                 ndr_print_WERROR(ndr, "result", r->out.result);
24717                 ndr->depth--;
24718         }
24719         ndr->depth--;
24720 }
24721
24722 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24723 {
24724         if (flags & NDR_IN) {
24725         }
24726         if (flags & NDR_OUT) {
24727                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24728         }
24729         return NDR_ERR_SUCCESS;
24730 }
24731
24732 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24733 {
24734         if (flags & NDR_IN) {
24735         }
24736         if (flags & NDR_OUT) {
24737                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24738         }
24739         return NDR_ERR_SUCCESS;
24740 }
24741
24742 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24743 {
24744         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24745         ndr->depth++;
24746         if (flags & NDR_SET_VALUES) {
24747                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24748         }
24749         if (flags & NDR_IN) {
24750                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24751                 ndr->depth++;
24752                 ndr->depth--;
24753         }
24754         if (flags & NDR_OUT) {
24755                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24756                 ndr->depth++;
24757                 ndr_print_WERROR(ndr, "result", r->out.result);
24758                 ndr->depth--;
24759         }
24760         ndr->depth--;
24761 }
24762
24763 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24764 {
24765         if (flags & NDR_IN) {
24766                 if (r->in.handle == NULL) {
24767                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24768                 }
24769                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24770                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24772                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24773                 if (r->in.local_machine) {
24774                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24777                         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));
24778                 }
24779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24780                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24781                 if (r->in.notify_options) {
24782                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24783                 }
24784         }
24785         if (flags & NDR_OUT) {
24786                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24787         }
24788         return NDR_ERR_SUCCESS;
24789 }
24790
24791 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24792 {
24793         uint32_t _ptr_local_machine;
24794         uint32_t _ptr_notify_options;
24795         TALLOC_CTX *_mem_save_handle_0;
24796         TALLOC_CTX *_mem_save_local_machine_0;
24797         TALLOC_CTX *_mem_save_notify_options_0;
24798         if (flags & NDR_IN) {
24799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24800                         NDR_PULL_ALLOC(ndr, r->in.handle);
24801                 }
24802                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24804                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24806                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
24808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
24809                 if (_ptr_local_machine) {
24810                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
24811                 } else {
24812                         r->in.local_machine = NULL;
24813                 }
24814                 if (r->in.local_machine) {
24815                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
24816                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
24817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
24818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
24819                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
24820                                 return 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));
24821                         }
24822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
24823                         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));
24824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
24825                 }
24826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24827                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
24828                 if (_ptr_notify_options) {
24829                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
24830                 } else {
24831                         r->in.notify_options = NULL;
24832                 }
24833                 if (r->in.notify_options) {
24834                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24835                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
24836                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24837                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
24838                 }
24839         }
24840         if (flags & NDR_OUT) {
24841                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24842         }
24843         return NDR_ERR_SUCCESS;
24844 }
24845
24846 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24847 {
24848         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24849         ndr->depth++;
24850         if (flags & NDR_SET_VALUES) {
24851                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24852         }
24853         if (flags & NDR_IN) {
24854                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24855                 ndr->depth++;
24856                 ndr_print_ptr(ndr, "handle", r->in.handle);
24857                 ndr->depth++;
24858                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24859                 ndr->depth--;
24860                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24861                 ndr_print_uint32(ndr, "options", r->in.options);
24862                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
24863                 ndr->depth++;
24864                 if (r->in.local_machine) {
24865                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
24866                 }
24867                 ndr->depth--;
24868                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24869                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
24870                 ndr->depth++;
24871                 if (r->in.notify_options) {
24872                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
24873                 }
24874                 ndr->depth--;
24875                 ndr->depth--;
24876         }
24877         if (flags & NDR_OUT) {
24878                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24879                 ndr->depth++;
24880                 ndr_print_WERROR(ndr, "result", r->out.result);
24881                 ndr->depth--;
24882         }
24883         ndr->depth--;
24884 }
24885
24886 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24887 {
24888         if (flags & NDR_IN) {
24889                 if (r->in.handle == NULL) {
24890                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24891                 }
24892                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24893                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
24894                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
24896                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24897                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24898         }
24899         if (flags & NDR_OUT) {
24900                 if (r->out.reply_result == NULL) {
24901                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24902                 }
24903                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
24904                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24905         }
24906         return NDR_ERR_SUCCESS;
24907 }
24908
24909 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
24910 {
24911         TALLOC_CTX *_mem_save_handle_0;
24912         TALLOC_CTX *_mem_save_reply_result_0;
24913         if (flags & NDR_IN) {
24914                 ZERO_STRUCT(r->out);
24915
24916                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24917                         NDR_PULL_ALLOC(ndr, r->in.handle);
24918                 }
24919                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24920                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24921                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24922                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
24924                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
24926                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24927                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24928                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
24929                 ZERO_STRUCTP(r->out.reply_result);
24930         }
24931         if (flags & NDR_OUT) {
24932                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24933                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
24934                 }
24935                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
24936                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
24937                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
24938                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
24939                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24940         }
24941         return NDR_ERR_SUCCESS;
24942 }
24943
24944 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24945 {
24946         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
24947         ndr->depth++;
24948         if (flags & NDR_SET_VALUES) {
24949                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24950         }
24951         if (flags & NDR_IN) {
24952                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
24953                 ndr->depth++;
24954                 ndr_print_ptr(ndr, "handle", r->in.handle);
24955                 ndr->depth++;
24956                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24957                 ndr->depth--;
24958                 ndr_print_uint32(ndr, "color", r->in.color);
24959                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24960                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
24961                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
24962                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
24963                 ndr->depth--;
24964         }
24965         if (flags & NDR_OUT) {
24966                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
24967                 ndr->depth++;
24968                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
24969                 ndr->depth++;
24970                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
24971                 ndr->depth--;
24972                 ndr_print_WERROR(ndr, "result", r->out.result);
24973                 ndr->depth--;
24974         }
24975         ndr->depth--;
24976 }
24977
24978 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
24979 {
24980         if (flags & NDR_IN) {
24981                 if (r->in.handle == NULL) {
24982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24983                 }
24984                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
24986                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
24987                 if (r->in.options) {
24988                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
24989                 }
24990         }
24991         if (flags & NDR_OUT) {
24992                 if (r->out.info == NULL) {
24993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24994                 }
24995                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
24996                 if (*r->out.info) {
24997                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
24998                 }
24999                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25000         }
25001         return NDR_ERR_SUCCESS;
25002 }
25003
25004 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25005 {
25006         uint32_t _ptr_options;
25007         uint32_t _ptr_info;
25008         TALLOC_CTX *_mem_save_handle_0;
25009         TALLOC_CTX *_mem_save_options_0;
25010         TALLOC_CTX *_mem_save_info_0;
25011         TALLOC_CTX *_mem_save_info_1;
25012         if (flags & NDR_IN) {
25013                 ZERO_STRUCT(r->out);
25014
25015                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25016                         NDR_PULL_ALLOC(ndr, r->in.handle);
25017                 }
25018                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25019                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25020                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25021                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25023                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25024                 if (_ptr_options) {
25025                         NDR_PULL_ALLOC(ndr, r->in.options);
25026                 } else {
25027                         r->in.options = NULL;
25028                 }
25029                 if (r->in.options) {
25030                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25031                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25032                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25033                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25034                 }
25035                 NDR_PULL_ALLOC(ndr, r->out.info);
25036                 ZERO_STRUCTP(r->out.info);
25037         }
25038         if (flags & NDR_OUT) {
25039                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25040                         NDR_PULL_ALLOC(ndr, r->out.info);
25041                 }
25042                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25043                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25044                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25045                 if (_ptr_info) {
25046                         NDR_PULL_ALLOC(ndr, *r->out.info);
25047                 } else {
25048                         *r->out.info = NULL;
25049                 }
25050                 if (*r->out.info) {
25051                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25052                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25053                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25054                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25055                 }
25056                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25057                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25058         }
25059         return NDR_ERR_SUCCESS;
25060 }
25061
25062 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25063 {
25064         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25065         ndr->depth++;
25066         if (flags & NDR_SET_VALUES) {
25067                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25068         }
25069         if (flags & NDR_IN) {
25070                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25071                 ndr->depth++;
25072                 ndr_print_ptr(ndr, "handle", r->in.handle);
25073                 ndr->depth++;
25074                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25075                 ndr->depth--;
25076                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25077                 ndr_print_ptr(ndr, "options", r->in.options);
25078                 ndr->depth++;
25079                 if (r->in.options) {
25080                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25081                 }
25082                 ndr->depth--;
25083                 ndr->depth--;
25084         }
25085         if (flags & NDR_OUT) {
25086                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25087                 ndr->depth++;
25088                 ndr_print_ptr(ndr, "info", r->out.info);
25089                 ndr->depth++;
25090                 ndr_print_ptr(ndr, "info", *r->out.info);
25091                 ndr->depth++;
25092                 if (*r->out.info) {
25093                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25094                 }
25095                 ndr->depth--;
25096                 ndr->depth--;
25097                 ndr_print_WERROR(ndr, "result", r->out.result);
25098                 ndr->depth--;
25099         }
25100         ndr->depth--;
25101 }
25102
25103 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25104 {
25105         if (flags & NDR_IN) {
25106         }
25107         if (flags & NDR_OUT) {
25108                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25109         }
25110         return NDR_ERR_SUCCESS;
25111 }
25112
25113 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25114 {
25115         if (flags & NDR_IN) {
25116         }
25117         if (flags & NDR_OUT) {
25118                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25119         }
25120         return NDR_ERR_SUCCESS;
25121 }
25122
25123 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25124 {
25125         ndr_print_struct(ndr, name, "spoolss_44");
25126         ndr->depth++;
25127         if (flags & NDR_SET_VALUES) {
25128                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25129         }
25130         if (flags & NDR_IN) {
25131                 ndr_print_struct(ndr, "in", "spoolss_44");
25132                 ndr->depth++;
25133                 ndr->depth--;
25134         }
25135         if (flags & NDR_OUT) {
25136                 ndr_print_struct(ndr, "out", "spoolss_44");
25137                 ndr->depth++;
25138                 ndr_print_WERROR(ndr, "result", r->out.result);
25139                 ndr->depth--;
25140         }
25141         ndr->depth--;
25142 }
25143
25144 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25145 {
25146         if (flags & NDR_IN) {
25147                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25148                 if (r->in.printername) {
25149                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25150                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25152                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25153                 }
25154                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25155                 if (r->in.datatype) {
25156                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25157                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25158                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25159                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25160                 }
25161                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25162                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25164                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25165                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25166         }
25167         if (flags & NDR_OUT) {
25168                 if (r->out.handle == NULL) {
25169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25170                 }
25171                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25172                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25173         }
25174         return NDR_ERR_SUCCESS;
25175 }
25176
25177 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25178 {
25179         uint32_t _ptr_printername;
25180         uint32_t _ptr_datatype;
25181         TALLOC_CTX *_mem_save_printername_0;
25182         TALLOC_CTX *_mem_save_datatype_0;
25183         TALLOC_CTX *_mem_save_handle_0;
25184         if (flags & NDR_IN) {
25185                 ZERO_STRUCT(r->out);
25186
25187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25188                 if (_ptr_printername) {
25189                         NDR_PULL_ALLOC(ndr, r->in.printername);
25190                 } else {
25191                         r->in.printername = NULL;
25192                 }
25193                 if (r->in.printername) {
25194                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25195                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25198                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25199                                 return 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));
25200                         }
25201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25204                 }
25205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25206                 if (_ptr_datatype) {
25207                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25208                 } else {
25209                         r->in.datatype = NULL;
25210                 }
25211                 if (r->in.datatype) {
25212                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25213                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25214                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25215                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25216                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25217                                 return 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));
25218                         }
25219                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25220                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25221                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25222                 }
25223                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25224                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25225                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25226                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25227                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25228                 NDR_PULL_ALLOC(ndr, r->out.handle);
25229                 ZERO_STRUCTP(r->out.handle);
25230         }
25231         if (flags & NDR_OUT) {
25232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25233                         NDR_PULL_ALLOC(ndr, r->out.handle);
25234                 }
25235                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25236                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25237                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25239                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25240         }
25241         return NDR_ERR_SUCCESS;
25242 }
25243
25244 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25245 {
25246         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25247         ndr->depth++;
25248         if (flags & NDR_SET_VALUES) {
25249                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25250         }
25251         if (flags & NDR_IN) {
25252                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25253                 ndr->depth++;
25254                 ndr_print_ptr(ndr, "printername", r->in.printername);
25255                 ndr->depth++;
25256                 if (r->in.printername) {
25257                         ndr_print_string(ndr, "printername", r->in.printername);
25258                 }
25259                 ndr->depth--;
25260                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25261                 ndr->depth++;
25262                 if (r->in.datatype) {
25263                         ndr_print_string(ndr, "datatype", r->in.datatype);
25264                 }
25265                 ndr->depth--;
25266                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25267                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25268                 ndr_print_uint32(ndr, "level", r->in.level);
25269                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25270                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25271                 ndr->depth--;
25272         }
25273         if (flags & NDR_OUT) {
25274                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25275                 ndr->depth++;
25276                 ndr_print_ptr(ndr, "handle", r->out.handle);
25277                 ndr->depth++;
25278                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25279                 ndr->depth--;
25280                 ndr_print_WERROR(ndr, "result", r->out.result);
25281                 ndr->depth--;
25282         }
25283         ndr->depth--;
25284 }
25285
25286 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25287 {
25288         if (flags & NDR_IN) {
25289                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25290                 if (r->in.server) {
25291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25292                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25293                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25294                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25295                 }
25296                 if (r->in.info_ctr == NULL) {
25297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25298                 }
25299                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25300                 if (r->in.devmode_ctr == NULL) {
25301                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25302                 }
25303                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25304                 if (r->in.secdesc_ctr == NULL) {
25305                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25306                 }
25307                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25308                 if (r->in.userlevel_ctr == NULL) {
25309                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25310                 }
25311                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25312         }
25313         if (flags & NDR_OUT) {
25314                 if (r->out.handle == NULL) {
25315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25316                 }
25317                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25318                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25319         }
25320         return NDR_ERR_SUCCESS;
25321 }
25322
25323 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25324 {
25325         uint32_t _ptr_server;
25326         TALLOC_CTX *_mem_save_server_0;
25327         TALLOC_CTX *_mem_save_info_ctr_0;
25328         TALLOC_CTX *_mem_save_devmode_ctr_0;
25329         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25330         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25331         TALLOC_CTX *_mem_save_handle_0;
25332         if (flags & NDR_IN) {
25333                 ZERO_STRUCT(r->out);
25334
25335                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25336                 if (_ptr_server) {
25337                         NDR_PULL_ALLOC(ndr, r->in.server);
25338                 } else {
25339                         r->in.server = NULL;
25340                 }
25341                 if (r->in.server) {
25342                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25343                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25344                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25345                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25346                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25347                                 return 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));
25348                         }
25349                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25350                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25351                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25352                 }
25353                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25354                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25355                 }
25356                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25357                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25358                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25359                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25361                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25362                 }
25363                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25364                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25365                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25368                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25369                 }
25370                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25371                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25372                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25373                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25374                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25375                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25376                 }
25377                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25378                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25379                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25380                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25381                 NDR_PULL_ALLOC(ndr, r->out.handle);
25382                 ZERO_STRUCTP(r->out.handle);
25383         }
25384         if (flags & NDR_OUT) {
25385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25386                         NDR_PULL_ALLOC(ndr, r->out.handle);
25387                 }
25388                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25390                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25392                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25393         }
25394         return NDR_ERR_SUCCESS;
25395 }
25396
25397 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25398 {
25399         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25400         ndr->depth++;
25401         if (flags & NDR_SET_VALUES) {
25402                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25403         }
25404         if (flags & NDR_IN) {
25405                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25406                 ndr->depth++;
25407                 ndr_print_ptr(ndr, "server", r->in.server);
25408                 ndr->depth++;
25409                 if (r->in.server) {
25410                         ndr_print_string(ndr, "server", r->in.server);
25411                 }
25412                 ndr->depth--;
25413                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25414                 ndr->depth++;
25415                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25416                 ndr->depth--;
25417                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25418                 ndr->depth++;
25419                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25420                 ndr->depth--;
25421                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25422                 ndr->depth++;
25423                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25424                 ndr->depth--;
25425                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25426                 ndr->depth++;
25427                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25428                 ndr->depth--;
25429                 ndr->depth--;
25430         }
25431         if (flags & NDR_OUT) {
25432                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25433                 ndr->depth++;
25434                 ndr_print_ptr(ndr, "handle", r->out.handle);
25435                 ndr->depth++;
25436                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25437                 ndr->depth--;
25438                 ndr_print_WERROR(ndr, "result", r->out.result);
25439                 ndr->depth--;
25440         }
25441         ndr->depth--;
25442 }
25443
25444 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25445 {
25446         if (flags & NDR_IN) {
25447         }
25448         if (flags & NDR_OUT) {
25449                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25450         }
25451         return NDR_ERR_SUCCESS;
25452 }
25453
25454 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25455 {
25456         if (flags & NDR_IN) {
25457         }
25458         if (flags & NDR_OUT) {
25459                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25460         }
25461         return NDR_ERR_SUCCESS;
25462 }
25463
25464 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25465 {
25466         ndr_print_struct(ndr, name, "spoolss_47");
25467         ndr->depth++;
25468         if (flags & NDR_SET_VALUES) {
25469                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25470         }
25471         if (flags & NDR_IN) {
25472                 ndr_print_struct(ndr, "in", "spoolss_47");
25473                 ndr->depth++;
25474                 ndr->depth--;
25475         }
25476         if (flags & NDR_OUT) {
25477                 ndr_print_struct(ndr, "out", "spoolss_47");
25478                 ndr->depth++;
25479                 ndr_print_WERROR(ndr, "result", r->out.result);
25480                 ndr->depth--;
25481         }
25482         ndr->depth--;
25483 }
25484
25485 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25486 {
25487         if (flags & NDR_IN) {
25488                 if (r->in.handle == NULL) {
25489                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25490                 }
25491                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25495         }
25496         if (flags & NDR_OUT) {
25497                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25498                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25499                 if (r->out.value_needed == NULL) {
25500                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25501                 }
25502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25503                 if (r->out.printerdata_type == NULL) {
25504                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25505                 }
25506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.printerdata_type));
25507                 if (r->out.buffer == NULL) {
25508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25509                 }
25510                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.buffer));
25511                 if (r->out.data_needed == NULL) {
25512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25513                 }
25514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25515                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25516         }
25517         return NDR_ERR_SUCCESS;
25518 }
25519
25520 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25521 {
25522         TALLOC_CTX *_mem_save_handle_0;
25523         TALLOC_CTX *_mem_save_value_needed_0;
25524         TALLOC_CTX *_mem_save_printerdata_type_0;
25525         TALLOC_CTX *_mem_save_buffer_0;
25526         TALLOC_CTX *_mem_save_data_needed_0;
25527         if (flags & NDR_IN) {
25528                 ZERO_STRUCT(r->out);
25529
25530                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25531                         NDR_PULL_ALLOC(ndr, r->in.handle);
25532                 }
25533                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25534                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25535                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25536                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25540                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25541                 ZERO_STRUCTP(r->out.value_needed);
25542                 NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25543                 ZERO_STRUCTP(r->out.printerdata_type);
25544                 NDR_PULL_ALLOC(ndr, r->out.buffer);
25545                 ZERO_STRUCTP(r->out.buffer);
25546                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25547                 ZERO_STRUCTP(r->out.data_needed);
25548         }
25549         if (flags & NDR_OUT) {
25550                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25551                 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));
25552                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25553                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25554                 }
25555                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25556                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25558                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25560                         NDR_PULL_ALLOC(ndr, r->out.printerdata_type);
25561                 }
25562                 _mem_save_printerdata_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25563                 NDR_PULL_SET_MEM_CTX(ndr, r->out.printerdata_type, LIBNDR_FLAG_REF_ALLOC);
25564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.printerdata_type));
25565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printerdata_type_0, LIBNDR_FLAG_REF_ALLOC);
25566                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25567                         NDR_PULL_ALLOC(ndr, r->out.buffer);
25568                 }
25569                 _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
25570                 NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, LIBNDR_FLAG_REF_ALLOC);
25571                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.buffer));
25572                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, LIBNDR_FLAG_REF_ALLOC);
25573                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25574                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25575                 }
25576                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25577                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25579                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25580                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25581                 if (r->out.value_name) {
25582                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25583                 }
25584         }
25585         return NDR_ERR_SUCCESS;
25586 }
25587
25588 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25589 {
25590         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25591         ndr->depth++;
25592         if (flags & NDR_SET_VALUES) {
25593                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25594         }
25595         if (flags & NDR_IN) {
25596                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25597                 ndr->depth++;
25598                 ndr_print_ptr(ndr, "handle", r->in.handle);
25599                 ndr->depth++;
25600                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25601                 ndr->depth--;
25602                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25603                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25604                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25605                 ndr->depth--;
25606         }
25607         if (flags & NDR_OUT) {
25608                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25609                 ndr->depth++;
25610                 ndr_print_string(ndr, "value_name", r->out.value_name);
25611                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25612                 ndr->depth++;
25613                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25614                 ndr->depth--;
25615                 ndr_print_ptr(ndr, "printerdata_type", r->out.printerdata_type);
25616                 ndr->depth++;
25617                 ndr_print_uint32(ndr, "printerdata_type", *r->out.printerdata_type);
25618                 ndr->depth--;
25619                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
25620                 ndr->depth++;
25621                 ndr_print_DATA_BLOB(ndr, "buffer", *r->out.buffer);
25622                 ndr->depth--;
25623                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25624                 ndr->depth++;
25625                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25626                 ndr->depth--;
25627                 ndr_print_WERROR(ndr, "result", r->out.result);
25628                 ndr->depth--;
25629         }
25630         ndr->depth--;
25631 }
25632
25633 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25634 {
25635         if (flags & NDR_IN) {
25636                 if (r->in.handle == NULL) {
25637                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25638                 }
25639                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25643                 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));
25644         }
25645         if (flags & NDR_OUT) {
25646                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25647         }
25648         return NDR_ERR_SUCCESS;
25649 }
25650
25651 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25652 {
25653         TALLOC_CTX *_mem_save_handle_0;
25654         if (flags & NDR_IN) {
25655                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25656                         NDR_PULL_ALLOC(ndr, r->in.handle);
25657                 }
25658                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25659                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25660                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25661                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25662                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25663                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25664                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25665                         return 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));
25666                 }
25667                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25668                 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));
25669         }
25670         if (flags & NDR_OUT) {
25671                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25672         }
25673         return NDR_ERR_SUCCESS;
25674 }
25675
25676 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25677 {
25678         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
25679         ndr->depth++;
25680         if (flags & NDR_SET_VALUES) {
25681                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25682         }
25683         if (flags & NDR_IN) {
25684                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
25685                 ndr->depth++;
25686                 ndr_print_ptr(ndr, "handle", r->in.handle);
25687                 ndr->depth++;
25688                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25689                 ndr->depth--;
25690                 ndr_print_string(ndr, "value_name", r->in.value_name);
25691                 ndr->depth--;
25692         }
25693         if (flags & NDR_OUT) {
25694                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
25695                 ndr->depth++;
25696                 ndr_print_WERROR(ndr, "result", r->out.result);
25697                 ndr->depth--;
25698         }
25699         ndr->depth--;
25700 }
25701
25702 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
25703 {
25704         if (flags & NDR_IN) {
25705         }
25706         if (flags & NDR_OUT) {
25707                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25708         }
25709         return NDR_ERR_SUCCESS;
25710 }
25711
25712 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
25713 {
25714         if (flags & NDR_IN) {
25715         }
25716         if (flags & NDR_OUT) {
25717                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25718         }
25719         return NDR_ERR_SUCCESS;
25720 }
25721
25722 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25723 {
25724         ndr_print_struct(ndr, name, "spoolss_4a");
25725         ndr->depth++;
25726         if (flags & NDR_SET_VALUES) {
25727                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25728         }
25729         if (flags & NDR_IN) {
25730                 ndr_print_struct(ndr, "in", "spoolss_4a");
25731                 ndr->depth++;
25732                 ndr->depth--;
25733         }
25734         if (flags & NDR_OUT) {
25735                 ndr_print_struct(ndr, "out", "spoolss_4a");
25736                 ndr->depth++;
25737                 ndr_print_WERROR(ndr, "result", r->out.result);
25738                 ndr->depth--;
25739         }
25740         ndr->depth--;
25741 }
25742
25743 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25744 {
25745         if (flags & NDR_IN) {
25746         }
25747         if (flags & NDR_OUT) {
25748                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25749         }
25750         return NDR_ERR_SUCCESS;
25751 }
25752
25753 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25754 {
25755         if (flags & NDR_IN) {
25756         }
25757         if (flags & NDR_OUT) {
25758                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25759         }
25760         return NDR_ERR_SUCCESS;
25761 }
25762
25763 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25764 {
25765         ndr_print_struct(ndr, name, "spoolss_4b");
25766         ndr->depth++;
25767         if (flags & NDR_SET_VALUES) {
25768                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25769         }
25770         if (flags & NDR_IN) {
25771                 ndr_print_struct(ndr, "in", "spoolss_4b");
25772                 ndr->depth++;
25773                 ndr->depth--;
25774         }
25775         if (flags & NDR_OUT) {
25776                 ndr_print_struct(ndr, "out", "spoolss_4b");
25777                 ndr->depth++;
25778                 ndr_print_WERROR(ndr, "result", r->out.result);
25779                 ndr->depth--;
25780         }
25781         ndr->depth--;
25782 }
25783
25784 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
25785 {
25786         if (flags & NDR_IN) {
25787         }
25788         if (flags & NDR_OUT) {
25789                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25790         }
25791         return NDR_ERR_SUCCESS;
25792 }
25793
25794 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
25795 {
25796         if (flags & NDR_IN) {
25797         }
25798         if (flags & NDR_OUT) {
25799                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25800         }
25801         return NDR_ERR_SUCCESS;
25802 }
25803
25804 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
25805 {
25806         ndr_print_struct(ndr, name, "spoolss_4c");
25807         ndr->depth++;
25808         if (flags & NDR_SET_VALUES) {
25809                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25810         }
25811         if (flags & NDR_IN) {
25812                 ndr_print_struct(ndr, "in", "spoolss_4c");
25813                 ndr->depth++;
25814                 ndr->depth--;
25815         }
25816         if (flags & NDR_OUT) {
25817                 ndr_print_struct(ndr, "out", "spoolss_4c");
25818                 ndr->depth++;
25819                 ndr_print_WERROR(ndr, "result", r->out.result);
25820                 ndr->depth--;
25821         }
25822         ndr->depth--;
25823 }
25824
25825 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
25826 {
25827         if (flags & NDR_IN) {
25828                 if (r->in.handle == NULL) {
25829                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25830                 }
25831                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25835                 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));
25836                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25839                 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));
25840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.type));
25841                 if (r->in.buffer == NULL) {
25842                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25843                 }
25844                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25845                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
25846                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25847         }
25848         if (flags & NDR_OUT) {
25849                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25850         }
25851         return NDR_ERR_SUCCESS;
25852 }
25853
25854 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
25855 {
25856         TALLOC_CTX *_mem_save_handle_0;
25857         if (flags & NDR_IN) {
25858                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25859                         NDR_PULL_ALLOC(ndr, r->in.handle);
25860                 }
25861                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25862                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25863                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25865                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25866                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25867                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25868                         return 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));
25869                 }
25870                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25871                 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));
25872                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25873                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25874                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25875                         return 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));
25876                 }
25877                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25878                 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));
25879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.type));
25880                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25881                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25882                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25883                 }
25884                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25885                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25886                 if (r->in.buffer) {
25887                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
25888                 }
25889         }
25890         if (flags & NDR_OUT) {
25891                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25892         }
25893         return NDR_ERR_SUCCESS;
25894 }
25895
25896 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
25897 {
25898         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
25899         ndr->depth++;
25900         if (flags & NDR_SET_VALUES) {
25901                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25902         }
25903         if (flags & NDR_IN) {
25904                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
25905                 ndr->depth++;
25906                 ndr_print_ptr(ndr, "handle", r->in.handle);
25907                 ndr->depth++;
25908                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25909                 ndr->depth--;
25910                 ndr_print_string(ndr, "key_name", r->in.key_name);
25911                 ndr_print_string(ndr, "value_name", r->in.value_name);
25912                 ndr_print_uint32(ndr, "type", r->in.type);
25913                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
25914                 ndr->depth++;
25915                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
25916                 ndr->depth--;
25917                 ndr_print_uint32(ndr, "offered", r->in.offered);
25918                 ndr->depth--;
25919         }
25920         if (flags & NDR_OUT) {
25921                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
25922                 ndr->depth++;
25923                 ndr_print_WERROR(ndr, "result", r->out.result);
25924                 ndr->depth--;
25925         }
25926         ndr->depth--;
25927 }
25928
25929 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
25930 {
25931         if (flags & NDR_IN) {
25932                 if (r->in.handle == NULL) {
25933                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25934                 }
25935                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25937                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25939                 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));
25940                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25941                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25942                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25943                 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));
25944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25945         }
25946         if (flags & NDR_OUT) {
25947                 if (r->out.type == NULL) {
25948                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25949                 }
25950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.type));
25951                 if (r->out.buffer == NULL) {
25952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25953                 }
25954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25955                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
25956                 if (r->out.needed == NULL) {
25957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25958                 }
25959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
25960                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25961         }
25962         return NDR_ERR_SUCCESS;
25963 }
25964
25965 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
25966 {
25967         TALLOC_CTX *_mem_save_handle_0;
25968         TALLOC_CTX *_mem_save_type_0;
25969         TALLOC_CTX *_mem_save_needed_0;
25970         if (flags & NDR_IN) {
25971                 ZERO_STRUCT(r->out);
25972
25973                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25974                         NDR_PULL_ALLOC(ndr, r->in.handle);
25975                 }
25976                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25977                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25978                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25980                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25981                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25982                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25983                         return 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));
25984                 }
25985                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25986                 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));
25987                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25988                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25989                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25990                         return 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));
25991                 }
25992                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25993                 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));
25994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25995                 NDR_PULL_ALLOC(ndr, r->out.type);
25996                 ZERO_STRUCTP(r->out.type);
25997                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
25998                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
25999                 NDR_PULL_ALLOC(ndr, r->out.needed);
26000                 ZERO_STRUCTP(r->out.needed);
26001         }
26002         if (flags & NDR_OUT) {
26003                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26004                         NDR_PULL_ALLOC(ndr, r->out.type);
26005                 }
26006                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26007                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.type));
26009                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26010                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26012                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26013                 }
26014                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26015                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26016                         NDR_PULL_ALLOC(ndr, r->out.needed);
26017                 }
26018                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26019                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26021                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26022                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26023                 if (r->out.buffer) {
26024                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26025                 }
26026         }
26027         return NDR_ERR_SUCCESS;
26028 }
26029
26030 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26031 {
26032         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26033         ndr->depth++;
26034         if (flags & NDR_SET_VALUES) {
26035                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26036         }
26037         if (flags & NDR_IN) {
26038                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26039                 ndr->depth++;
26040                 ndr_print_ptr(ndr, "handle", r->in.handle);
26041                 ndr->depth++;
26042                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26043                 ndr->depth--;
26044                 ndr_print_string(ndr, "key_name", r->in.key_name);
26045                 ndr_print_string(ndr, "value_name", r->in.value_name);
26046                 ndr_print_uint32(ndr, "offered", r->in.offered);
26047                 ndr->depth--;
26048         }
26049         if (flags & NDR_OUT) {
26050                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26051                 ndr->depth++;
26052                 ndr_print_ptr(ndr, "type", r->out.type);
26053                 ndr->depth++;
26054                 ndr_print_uint32(ndr, "type", *r->out.type);
26055                 ndr->depth--;
26056                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26057                 ndr->depth++;
26058                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26059                 ndr->depth--;
26060                 ndr_print_ptr(ndr, "needed", r->out.needed);
26061                 ndr->depth++;
26062                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26063                 ndr->depth--;
26064                 ndr_print_WERROR(ndr, "result", r->out.result);
26065                 ndr->depth--;
26066         }
26067         ndr->depth--;
26068 }
26069
26070 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
26071 {
26072         if (flags & NDR_IN) {
26073                 if (r->in.handle == NULL) {
26074                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26075                 }
26076                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26078                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26080                 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));
26081                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26082         }
26083         if (flags & NDR_OUT) {
26084                 if (r->out.buffer == NULL) {
26085                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26086                 }
26087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26088                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26089                 if (r->out.needed == NULL) {
26090                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26091                 }
26092                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26093                 if (r->out.count == NULL) {
26094                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26095                 }
26096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26097                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26098         }
26099         return NDR_ERR_SUCCESS;
26100 }
26101
26102 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
26103 {
26104         TALLOC_CTX *_mem_save_handle_0;
26105         TALLOC_CTX *_mem_save_needed_0;
26106         TALLOC_CTX *_mem_save_count_0;
26107         if (flags & NDR_IN) {
26108                 ZERO_STRUCT(r->out);
26109
26110                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26111                         NDR_PULL_ALLOC(ndr, r->in.handle);
26112                 }
26113                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26114                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26115                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26116                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26117                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26118                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26119                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26120                         return 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));
26121                 }
26122                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26123                 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));
26124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26125                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26126                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26127                 NDR_PULL_ALLOC(ndr, r->out.needed);
26128                 ZERO_STRUCTP(r->out.needed);
26129                 NDR_PULL_ALLOC(ndr, r->out.count);
26130                 ZERO_STRUCTP(r->out.count);
26131         }
26132         if (flags & NDR_OUT) {
26133                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26135                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26136                 }
26137                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26138                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26139                         NDR_PULL_ALLOC(ndr, r->out.needed);
26140                 }
26141                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26142                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26146                         NDR_PULL_ALLOC(ndr, r->out.count);
26147                 }
26148                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26149                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26153                 if (r->out.buffer) {
26154                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26155                 }
26156         }
26157         return NDR_ERR_SUCCESS;
26158 }
26159
26160 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26161 {
26162         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26163         ndr->depth++;
26164         if (flags & NDR_SET_VALUES) {
26165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26166         }
26167         if (flags & NDR_IN) {
26168                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26169                 ndr->depth++;
26170                 ndr_print_ptr(ndr, "handle", r->in.handle);
26171                 ndr->depth++;
26172                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26173                 ndr->depth--;
26174                 ndr_print_string(ndr, "key_name", r->in.key_name);
26175                 ndr_print_uint32(ndr, "offered", r->in.offered);
26176                 ndr->depth--;
26177         }
26178         if (flags & NDR_OUT) {
26179                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26180                 ndr->depth++;
26181                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26182                 ndr->depth++;
26183                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26184                 ndr->depth--;
26185                 ndr_print_ptr(ndr, "needed", r->out.needed);
26186                 ndr->depth++;
26187                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26188                 ndr->depth--;
26189                 ndr_print_ptr(ndr, "count", r->out.count);
26190                 ndr->depth++;
26191                 ndr_print_uint32(ndr, "count", *r->out.count);
26192                 ndr->depth--;
26193                 ndr_print_WERROR(ndr, "result", r->out.result);
26194                 ndr->depth--;
26195         }
26196         ndr->depth--;
26197 }
26198
26199 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26200 {
26201         uint32_t cntr_key_buffer_1;
26202         if (flags & NDR_IN) {
26203                 if (r->in.handle == NULL) {
26204                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26205                 }
26206                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26207                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26208                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26209                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26210                 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));
26211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size));
26212         }
26213         if (flags & NDR_OUT) {
26214                 if (r->out.key_buffer == NULL) {
26215                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26216                 }
26217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.key_buffer_size / 2));
26218                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26219                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
26220                 }
26221                 if (r->out.needed == NULL) {
26222                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26223                 }
26224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26225                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26226         }
26227         return NDR_ERR_SUCCESS;
26228 }
26229
26230 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26231 {
26232         uint32_t cntr_key_buffer_1;
26233         TALLOC_CTX *_mem_save_handle_0;
26234         TALLOC_CTX *_mem_save_key_buffer_1;
26235         TALLOC_CTX *_mem_save_needed_0;
26236         if (flags & NDR_IN) {
26237                 ZERO_STRUCT(r->out);
26238
26239                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26240                         NDR_PULL_ALLOC(ndr, r->in.handle);
26241                 }
26242                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26243                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26244                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26245                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26246                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26247                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26248                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26249                         return 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));
26250                 }
26251                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26252                 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));
26253                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.key_buffer_size));
26254                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.key_buffer_size / 2);
26255                 memset(r->out.key_buffer, 0, (r->in.key_buffer_size / 2) * sizeof(*r->out.key_buffer));
26256                 NDR_PULL_ALLOC(ndr, r->out.needed);
26257                 ZERO_STRUCTP(r->out.needed);
26258         }
26259         if (flags & NDR_OUT) {
26260                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
26261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26262                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
26263                 }
26264                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26265                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
26266                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.key_buffer_size / 2; cntr_key_buffer_1++) {
26267                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
26268                 }
26269                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26270                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26271                         NDR_PULL_ALLOC(ndr, r->out.needed);
26272                 }
26273                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26274                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26276                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26277                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26278                 if (r->out.key_buffer) {
26279                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.key_buffer_size / 2));
26280                 }
26281         }
26282         return NDR_ERR_SUCCESS;
26283 }
26284
26285 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26286 {
26287         uint32_t cntr_key_buffer_1;
26288         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26289         ndr->depth++;
26290         if (flags & NDR_SET_VALUES) {
26291                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26292         }
26293         if (flags & NDR_IN) {
26294                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26295                 ndr->depth++;
26296                 ndr_print_ptr(ndr, "handle", r->in.handle);
26297                 ndr->depth++;
26298                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26299                 ndr->depth--;
26300                 ndr_print_string(ndr, "key_name", r->in.key_name);
26301                 ndr_print_uint32(ndr, "key_buffer_size", r->in.key_buffer_size);
26302                 ndr->depth--;
26303         }
26304         if (flags & NDR_OUT) {
26305                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26306                 ndr->depth++;
26307                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26308                 ndr->depth++;
26309                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.key_buffer_size / 2);
26310                 ndr->depth++;
26311                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.key_buffer_size / 2;cntr_key_buffer_1++) {
26312                         char *idx_1=NULL;
26313                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
26314                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
26315                                 free(idx_1);
26316                         }
26317                 }
26318                 ndr->depth--;
26319                 ndr->depth--;
26320                 ndr_print_ptr(ndr, "needed", r->out.needed);
26321                 ndr->depth++;
26322                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26323                 ndr->depth--;
26324                 ndr_print_WERROR(ndr, "result", r->out.result);
26325                 ndr->depth--;
26326         }
26327         ndr->depth--;
26328 }
26329
26330 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26331 {
26332         if (flags & NDR_IN) {
26333                 if (r->in.handle == NULL) {
26334                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26335                 }
26336                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26340                 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));
26341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26344                 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));
26345         }
26346         if (flags & NDR_OUT) {
26347                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26348         }
26349         return NDR_ERR_SUCCESS;
26350 }
26351
26352 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26353 {
26354         TALLOC_CTX *_mem_save_handle_0;
26355         if (flags & NDR_IN) {
26356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26357                         NDR_PULL_ALLOC(ndr, r->in.handle);
26358                 }
26359                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26360                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26361                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26363                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26364                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26365                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26366                         return 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));
26367                 }
26368                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26369                 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));
26370                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26371                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26372                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26373                         return 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));
26374                 }
26375                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26376                 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));
26377         }
26378         if (flags & NDR_OUT) {
26379                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26380         }
26381         return NDR_ERR_SUCCESS;
26382 }
26383
26384 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26385 {
26386         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26387         ndr->depth++;
26388         if (flags & NDR_SET_VALUES) {
26389                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26390         }
26391         if (flags & NDR_IN) {
26392                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26393                 ndr->depth++;
26394                 ndr_print_ptr(ndr, "handle", r->in.handle);
26395                 ndr->depth++;
26396                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26397                 ndr->depth--;
26398                 ndr_print_string(ndr, "key_name", r->in.key_name);
26399                 ndr_print_string(ndr, "value_name", r->in.value_name);
26400                 ndr->depth--;
26401         }
26402         if (flags & NDR_OUT) {
26403                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26404                 ndr->depth++;
26405                 ndr_print_WERROR(ndr, "result", r->out.result);
26406                 ndr->depth--;
26407         }
26408         ndr->depth--;
26409 }
26410
26411 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26412 {
26413         if (flags & NDR_IN) {
26414                 if (r->in.handle == NULL) {
26415                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26416                 }
26417                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26421                 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));
26422         }
26423         if (flags & NDR_OUT) {
26424                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26425         }
26426         return NDR_ERR_SUCCESS;
26427 }
26428
26429 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26430 {
26431         TALLOC_CTX *_mem_save_handle_0;
26432         if (flags & NDR_IN) {
26433                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26434                         NDR_PULL_ALLOC(ndr, r->in.handle);
26435                 }
26436                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26437                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26438                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26439                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26440                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26441                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26442                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26443                         return 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));
26444                 }
26445                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26446                 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));
26447         }
26448         if (flags & NDR_OUT) {
26449                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26450         }
26451         return NDR_ERR_SUCCESS;
26452 }
26453
26454 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26455 {
26456         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26457         ndr->depth++;
26458         if (flags & NDR_SET_VALUES) {
26459                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26460         }
26461         if (flags & NDR_IN) {
26462                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26463                 ndr->depth++;
26464                 ndr_print_ptr(ndr, "handle", r->in.handle);
26465                 ndr->depth++;
26466                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26467                 ndr->depth--;
26468                 ndr_print_string(ndr, "key_name", r->in.key_name);
26469                 ndr->depth--;
26470         }
26471         if (flags & NDR_OUT) {
26472                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26473                 ndr->depth++;
26474                 ndr_print_WERROR(ndr, "result", r->out.result);
26475                 ndr->depth--;
26476         }
26477         ndr->depth--;
26478 }
26479
26480 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26481 {
26482         if (flags & NDR_IN) {
26483         }
26484         if (flags & NDR_OUT) {
26485                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26486         }
26487         return NDR_ERR_SUCCESS;
26488 }
26489
26490 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26491 {
26492         if (flags & NDR_IN) {
26493         }
26494         if (flags & NDR_OUT) {
26495                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26496         }
26497         return NDR_ERR_SUCCESS;
26498 }
26499
26500 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26501 {
26502         ndr_print_struct(ndr, name, "spoolss_53");
26503         ndr->depth++;
26504         if (flags & NDR_SET_VALUES) {
26505                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26506         }
26507         if (flags & NDR_IN) {
26508                 ndr_print_struct(ndr, "in", "spoolss_53");
26509                 ndr->depth++;
26510                 ndr->depth--;
26511         }
26512         if (flags & NDR_OUT) {
26513                 ndr_print_struct(ndr, "out", "spoolss_53");
26514                 ndr->depth++;
26515                 ndr_print_WERROR(ndr, "result", r->out.result);
26516                 ndr->depth--;
26517         }
26518         ndr->depth--;
26519 }
26520
26521 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26522 {
26523         if (flags & NDR_IN) {
26524                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26525                 if (r->in.server) {
26526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26527                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26528                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26529                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26530                 }
26531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26534                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26538                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26539                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26541         }
26542         if (flags & NDR_OUT) {
26543                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26544         }
26545         return NDR_ERR_SUCCESS;
26546 }
26547
26548 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26549 {
26550         uint32_t _ptr_server;
26551         TALLOC_CTX *_mem_save_server_0;
26552         if (flags & NDR_IN) {
26553                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26554                 if (_ptr_server) {
26555                         NDR_PULL_ALLOC(ndr, r->in.server);
26556                 } else {
26557                         r->in.server = NULL;
26558                 }
26559                 if (r->in.server) {
26560                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26561                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26562                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26563                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26564                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26565                                 return 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));
26566                         }
26567                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26568                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26569                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26570                 }
26571                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26572                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26573                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26574                         return 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));
26575                 }
26576                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26577                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26578                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26579                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26580                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26581                         return 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));
26582                 }
26583                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26584                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26585                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26586                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26587         }
26588         if (flags & NDR_OUT) {
26589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26590         }
26591         return NDR_ERR_SUCCESS;
26592 }
26593
26594 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26595 {
26596         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26597         ndr->depth++;
26598         if (flags & NDR_SET_VALUES) {
26599                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26600         }
26601         if (flags & NDR_IN) {
26602                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26603                 ndr->depth++;
26604                 ndr_print_ptr(ndr, "server", r->in.server);
26605                 ndr->depth++;
26606                 if (r->in.server) {
26607                         ndr_print_string(ndr, "server", r->in.server);
26608                 }
26609                 ndr->depth--;
26610                 ndr_print_string(ndr, "architecture", r->in.architecture);
26611                 ndr_print_string(ndr, "driver", r->in.driver);
26612                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26613                 ndr_print_uint32(ndr, "version", r->in.version);
26614                 ndr->depth--;
26615         }
26616         if (flags & NDR_OUT) {
26617                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26618                 ndr->depth++;
26619                 ndr_print_WERROR(ndr, "result", r->out.result);
26620                 ndr->depth--;
26621         }
26622         ndr->depth--;
26623 }
26624
26625 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26626 {
26627         if (flags & NDR_IN) {
26628         }
26629         if (flags & NDR_OUT) {
26630                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26631         }
26632         return NDR_ERR_SUCCESS;
26633 }
26634
26635 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26636 {
26637         if (flags & NDR_IN) {
26638         }
26639         if (flags & NDR_OUT) {
26640                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26641         }
26642         return NDR_ERR_SUCCESS;
26643 }
26644
26645 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26646 {
26647         ndr_print_struct(ndr, name, "spoolss_55");
26648         ndr->depth++;
26649         if (flags & NDR_SET_VALUES) {
26650                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26651         }
26652         if (flags & NDR_IN) {
26653                 ndr_print_struct(ndr, "in", "spoolss_55");
26654                 ndr->depth++;
26655                 ndr->depth--;
26656         }
26657         if (flags & NDR_OUT) {
26658                 ndr_print_struct(ndr, "out", "spoolss_55");
26659                 ndr->depth++;
26660                 ndr_print_WERROR(ndr, "result", r->out.result);
26661                 ndr->depth--;
26662         }
26663         ndr->depth--;
26664 }
26665
26666 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26667 {
26668         if (flags & NDR_IN) {
26669         }
26670         if (flags & NDR_OUT) {
26671                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26672         }
26673         return NDR_ERR_SUCCESS;
26674 }
26675
26676 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26677 {
26678         if (flags & NDR_IN) {
26679         }
26680         if (flags & NDR_OUT) {
26681                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26682         }
26683         return NDR_ERR_SUCCESS;
26684 }
26685
26686 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26687 {
26688         ndr_print_struct(ndr, name, "spoolss_56");
26689         ndr->depth++;
26690         if (flags & NDR_SET_VALUES) {
26691                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26692         }
26693         if (flags & NDR_IN) {
26694                 ndr_print_struct(ndr, "in", "spoolss_56");
26695                 ndr->depth++;
26696                 ndr->depth--;
26697         }
26698         if (flags & NDR_OUT) {
26699                 ndr_print_struct(ndr, "out", "spoolss_56");
26700                 ndr->depth++;
26701                 ndr_print_WERROR(ndr, "result", r->out.result);
26702                 ndr->depth--;
26703         }
26704         ndr->depth--;
26705 }
26706
26707 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
26708 {
26709         if (flags & NDR_IN) {
26710         }
26711         if (flags & NDR_OUT) {
26712                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26713         }
26714         return NDR_ERR_SUCCESS;
26715 }
26716
26717 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
26718 {
26719         if (flags & NDR_IN) {
26720         }
26721         if (flags & NDR_OUT) {
26722                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26723         }
26724         return NDR_ERR_SUCCESS;
26725 }
26726
26727 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
26728 {
26729         ndr_print_struct(ndr, name, "spoolss_57");
26730         ndr->depth++;
26731         if (flags & NDR_SET_VALUES) {
26732                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26733         }
26734         if (flags & NDR_IN) {
26735                 ndr_print_struct(ndr, "in", "spoolss_57");
26736                 ndr->depth++;
26737                 ndr->depth--;
26738         }
26739         if (flags & NDR_OUT) {
26740                 ndr_print_struct(ndr, "out", "spoolss_57");
26741                 ndr->depth++;
26742                 ndr_print_WERROR(ndr, "result", r->out.result);
26743                 ndr->depth--;
26744         }
26745         ndr->depth--;
26746 }
26747
26748 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
26749 {
26750         if (flags & NDR_IN) {
26751                 if (r->in.handle == NULL) {
26752                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26753                 }
26754                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26758                 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));
26759                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
26760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
26761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26762                 if (r->in.status_code == NULL) {
26763                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26764                 }
26765                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
26766         }
26767         if (flags & NDR_OUT) {
26768                 if (r->out.out_data == NULL) {
26769                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26770                 }
26771                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26772                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
26773                 if (r->out.needed == NULL) {
26774                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26775                 }
26776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26777                 if (r->out.status_code == NULL) {
26778                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26779                 }
26780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
26781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26782         }
26783         return NDR_ERR_SUCCESS;
26784 }
26785
26786 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
26787 {
26788         TALLOC_CTX *_mem_save_handle_0;
26789         TALLOC_CTX *_mem_save_needed_0;
26790         TALLOC_CTX *_mem_save_status_code_0;
26791         if (flags & NDR_IN) {
26792                 ZERO_STRUCT(r->out);
26793
26794                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26795                         NDR_PULL_ALLOC(ndr, r->in.handle);
26796                 }
26797                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26798                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26799                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26800                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26801                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
26802                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
26803                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
26804                         return 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));
26805                 }
26806                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
26807                 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));
26808                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
26809                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
26810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
26811                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26812                         NDR_PULL_ALLOC(ndr, r->in.status_code);
26813                 }
26814                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26815                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
26816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
26817                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26818                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
26819                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
26820                 NDR_PULL_ALLOC(ndr, r->out.needed);
26821                 ZERO_STRUCTP(r->out.needed);
26822                 NDR_PULL_ALLOC(ndr, r->out.status_code);
26823                 *r->out.status_code = *r->in.status_code;
26824         }
26825         if (flags & NDR_OUT) {
26826                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
26827                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26828                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
26829                 }
26830                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
26831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26832                         NDR_PULL_ALLOC(ndr, r->out.needed);
26833                 }
26834                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26835                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26839                         NDR_PULL_ALLOC(ndr, r->out.status_code);
26840                 }
26841                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26842                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
26843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
26844                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26845                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26846                 if (r->out.out_data) {
26847                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
26848                 }
26849         }
26850         return NDR_ERR_SUCCESS;
26851 }
26852
26853 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
26854 {
26855         ndr_print_struct(ndr, name, "spoolss_XcvData");
26856         ndr->depth++;
26857         if (flags & NDR_SET_VALUES) {
26858                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26859         }
26860         if (flags & NDR_IN) {
26861                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
26862                 ndr->depth++;
26863                 ndr_print_ptr(ndr, "handle", r->in.handle);
26864                 ndr->depth++;
26865                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26866                 ndr->depth--;
26867                 ndr_print_string(ndr, "function_name", r->in.function_name);
26868                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
26869                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
26870                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
26871                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
26872                 ndr->depth++;
26873                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
26874                 ndr->depth--;
26875                 ndr->depth--;
26876         }
26877         if (flags & NDR_OUT) {
26878                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
26879                 ndr->depth++;
26880                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
26881                 ndr->depth++;
26882                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
26883                 ndr->depth--;
26884                 ndr_print_ptr(ndr, "needed", r->out.needed);
26885                 ndr->depth++;
26886                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26887                 ndr->depth--;
26888                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
26889                 ndr->depth++;
26890                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
26891                 ndr->depth--;
26892                 ndr_print_WERROR(ndr, "result", r->out.result);
26893                 ndr->depth--;
26894         }
26895         ndr->depth--;
26896 }
26897
26898 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
26899 {
26900         if (flags & NDR_IN) {
26901                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
26902                 if (r->in.servername) {
26903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
26906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26907                 }
26908                 if (r->in.info_ctr == NULL) {
26909                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26910                 }
26911                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26912                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
26913         }
26914         if (flags & NDR_OUT) {
26915                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26916         }
26917         return NDR_ERR_SUCCESS;
26918 }
26919
26920 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
26921 {
26922         uint32_t _ptr_servername;
26923         TALLOC_CTX *_mem_save_servername_0;
26924         TALLOC_CTX *_mem_save_info_ctr_0;
26925         if (flags & NDR_IN) {
26926                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
26927                 if (_ptr_servername) {
26928                         NDR_PULL_ALLOC(ndr, r->in.servername);
26929                 } else {
26930                         r->in.servername = NULL;
26931                 }
26932                 if (r->in.servername) {
26933                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
26934                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
26935                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
26936                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
26937                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
26938                                 return 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));
26939                         }
26940                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
26941                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
26942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
26943                 }
26944                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26945                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
26946                 }
26947                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
26948                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
26949                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
26950                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
26951                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
26952         }
26953         if (flags & NDR_OUT) {
26954                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26955         }
26956         return NDR_ERR_SUCCESS;
26957 }
26958
26959 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
26960 {
26961         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
26962         ndr->depth++;
26963         if (flags & NDR_SET_VALUES) {
26964                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26965         }
26966         if (flags & NDR_IN) {
26967                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
26968                 ndr->depth++;
26969                 ndr_print_ptr(ndr, "servername", r->in.servername);
26970                 ndr->depth++;
26971                 if (r->in.servername) {
26972                         ndr_print_string(ndr, "servername", r->in.servername);
26973                 }
26974                 ndr->depth--;
26975                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
26976                 ndr->depth++;
26977                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
26978                 ndr->depth--;
26979                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
26980                 ndr->depth--;
26981         }
26982         if (flags & NDR_OUT) {
26983                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
26984                 ndr->depth++;
26985                 ndr_print_WERROR(ndr, "result", r->out.result);
26986                 ndr->depth--;
26987         }
26988         ndr->depth--;
26989 }
26990
26991 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
26992 {
26993         if (flags & NDR_IN) {
26994         }
26995         if (flags & NDR_OUT) {
26996                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26997         }
26998         return NDR_ERR_SUCCESS;
26999 }
27000
27001 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27002 {
27003         if (flags & NDR_IN) {
27004         }
27005         if (flags & NDR_OUT) {
27006                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27007         }
27008         return NDR_ERR_SUCCESS;
27009 }
27010
27011 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27012 {
27013         ndr_print_struct(ndr, name, "spoolss_5a");
27014         ndr->depth++;
27015         if (flags & NDR_SET_VALUES) {
27016                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27017         }
27018         if (flags & NDR_IN) {
27019                 ndr_print_struct(ndr, "in", "spoolss_5a");
27020                 ndr->depth++;
27021                 ndr->depth--;
27022         }
27023         if (flags & NDR_OUT) {
27024                 ndr_print_struct(ndr, "out", "spoolss_5a");
27025                 ndr->depth++;
27026                 ndr_print_WERROR(ndr, "result", r->out.result);
27027                 ndr->depth--;
27028         }
27029         ndr->depth--;
27030 }
27031
27032 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27033 {
27034         if (flags & NDR_IN) {
27035         }
27036         if (flags & NDR_OUT) {
27037                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27038         }
27039         return NDR_ERR_SUCCESS;
27040 }
27041
27042 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27043 {
27044         if (flags & NDR_IN) {
27045         }
27046         if (flags & NDR_OUT) {
27047                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27048         }
27049         return NDR_ERR_SUCCESS;
27050 }
27051
27052 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27053 {
27054         ndr_print_struct(ndr, name, "spoolss_5b");
27055         ndr->depth++;
27056         if (flags & NDR_SET_VALUES) {
27057                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27058         }
27059         if (flags & NDR_IN) {
27060                 ndr_print_struct(ndr, "in", "spoolss_5b");
27061                 ndr->depth++;
27062                 ndr->depth--;
27063         }
27064         if (flags & NDR_OUT) {
27065                 ndr_print_struct(ndr, "out", "spoolss_5b");
27066                 ndr->depth++;
27067                 ndr_print_WERROR(ndr, "result", r->out.result);
27068                 ndr->depth--;
27069         }
27070         ndr->depth--;
27071 }
27072
27073 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27074 {
27075         if (flags & NDR_IN) {
27076         }
27077         if (flags & NDR_OUT) {
27078                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27079         }
27080         return NDR_ERR_SUCCESS;
27081 }
27082
27083 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27084 {
27085         if (flags & NDR_IN) {
27086         }
27087         if (flags & NDR_OUT) {
27088                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27089         }
27090         return NDR_ERR_SUCCESS;
27091 }
27092
27093 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27094 {
27095         ndr_print_struct(ndr, name, "spoolss_5c");
27096         ndr->depth++;
27097         if (flags & NDR_SET_VALUES) {
27098                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27099         }
27100         if (flags & NDR_IN) {
27101                 ndr_print_struct(ndr, "in", "spoolss_5c");
27102                 ndr->depth++;
27103                 ndr->depth--;
27104         }
27105         if (flags & NDR_OUT) {
27106                 ndr_print_struct(ndr, "out", "spoolss_5c");
27107                 ndr->depth++;
27108                 ndr_print_WERROR(ndr, "result", r->out.result);
27109                 ndr->depth--;
27110         }
27111         ndr->depth--;
27112 }
27113
27114 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27115 {
27116         if (flags & NDR_IN) {
27117         }
27118         if (flags & NDR_OUT) {
27119                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27120         }
27121         return NDR_ERR_SUCCESS;
27122 }
27123
27124 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27125 {
27126         if (flags & NDR_IN) {
27127         }
27128         if (flags & NDR_OUT) {
27129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27130         }
27131         return NDR_ERR_SUCCESS;
27132 }
27133
27134 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27135 {
27136         ndr_print_struct(ndr, name, "spoolss_5d");
27137         ndr->depth++;
27138         if (flags & NDR_SET_VALUES) {
27139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27140         }
27141         if (flags & NDR_IN) {
27142                 ndr_print_struct(ndr, "in", "spoolss_5d");
27143                 ndr->depth++;
27144                 ndr->depth--;
27145         }
27146         if (flags & NDR_OUT) {
27147                 ndr_print_struct(ndr, "out", "spoolss_5d");
27148                 ndr->depth++;
27149                 ndr_print_WERROR(ndr, "result", r->out.result);
27150                 ndr->depth--;
27151         }
27152         ndr->depth--;
27153 }
27154
27155 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27156 {
27157         if (flags & NDR_IN) {
27158         }
27159         if (flags & NDR_OUT) {
27160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27161         }
27162         return NDR_ERR_SUCCESS;
27163 }
27164
27165 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27166 {
27167         if (flags & NDR_IN) {
27168         }
27169         if (flags & NDR_OUT) {
27170                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27171         }
27172         return NDR_ERR_SUCCESS;
27173 }
27174
27175 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27176 {
27177         ndr_print_struct(ndr, name, "spoolss_5e");
27178         ndr->depth++;
27179         if (flags & NDR_SET_VALUES) {
27180                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27181         }
27182         if (flags & NDR_IN) {
27183                 ndr_print_struct(ndr, "in", "spoolss_5e");
27184                 ndr->depth++;
27185                 ndr->depth--;
27186         }
27187         if (flags & NDR_OUT) {
27188                 ndr_print_struct(ndr, "out", "spoolss_5e");
27189                 ndr->depth++;
27190                 ndr_print_WERROR(ndr, "result", r->out.result);
27191                 ndr->depth--;
27192         }
27193         ndr->depth--;
27194 }
27195
27196 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27197 {
27198         if (flags & NDR_IN) {
27199         }
27200         if (flags & NDR_OUT) {
27201                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27202         }
27203         return NDR_ERR_SUCCESS;
27204 }
27205
27206 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27207 {
27208         if (flags & NDR_IN) {
27209         }
27210         if (flags & NDR_OUT) {
27211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27212         }
27213         return NDR_ERR_SUCCESS;
27214 }
27215
27216 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27217 {
27218         ndr_print_struct(ndr, name, "spoolss_5f");
27219         ndr->depth++;
27220         if (flags & NDR_SET_VALUES) {
27221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27222         }
27223         if (flags & NDR_IN) {
27224                 ndr_print_struct(ndr, "in", "spoolss_5f");
27225                 ndr->depth++;
27226                 ndr->depth--;
27227         }
27228         if (flags & NDR_OUT) {
27229                 ndr_print_struct(ndr, "out", "spoolss_5f");
27230                 ndr->depth++;
27231                 ndr_print_WERROR(ndr, "result", r->out.result);
27232                 ndr->depth--;
27233         }
27234         ndr->depth--;
27235 }
27236
27237 static const struct ndr_interface_call spoolss_calls[] = {
27238         {
27239                 "spoolss_EnumPrinters",
27240                 sizeof(struct spoolss_EnumPrinters),
27241                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27242                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27243                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27244                 false,
27245         },
27246         {
27247                 "spoolss_OpenPrinter",
27248                 sizeof(struct spoolss_OpenPrinter),
27249                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27250                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27251                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27252                 false,
27253         },
27254         {
27255                 "spoolss_SetJob",
27256                 sizeof(struct spoolss_SetJob),
27257                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27258                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27259                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27260                 false,
27261         },
27262         {
27263                 "spoolss_GetJob",
27264                 sizeof(struct spoolss_GetJob),
27265                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27266                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27267                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27268                 false,
27269         },
27270         {
27271                 "spoolss_EnumJobs",
27272                 sizeof(struct spoolss_EnumJobs),
27273                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27274                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27275                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27276                 false,
27277         },
27278         {
27279                 "spoolss_AddPrinter",
27280                 sizeof(struct spoolss_AddPrinter),
27281                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27282                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27283                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27284                 false,
27285         },
27286         {
27287                 "spoolss_DeletePrinter",
27288                 sizeof(struct spoolss_DeletePrinter),
27289                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27290                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27291                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27292                 false,
27293         },
27294         {
27295                 "spoolss_SetPrinter",
27296                 sizeof(struct spoolss_SetPrinter),
27297                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27298                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27299                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27300                 false,
27301         },
27302         {
27303                 "spoolss_GetPrinter",
27304                 sizeof(struct spoolss_GetPrinter),
27305                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27306                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27307                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27308                 false,
27309         },
27310         {
27311                 "spoolss_AddPrinterDriver",
27312                 sizeof(struct spoolss_AddPrinterDriver),
27313                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27314                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27315                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27316                 false,
27317         },
27318         {
27319                 "spoolss_EnumPrinterDrivers",
27320                 sizeof(struct spoolss_EnumPrinterDrivers),
27321                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27322                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27323                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27324                 false,
27325         },
27326         {
27327                 "spoolss_GetPrinterDriver",
27328                 sizeof(struct spoolss_GetPrinterDriver),
27329                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27330                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27331                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27332                 false,
27333         },
27334         {
27335                 "spoolss_GetPrinterDriverDirectory",
27336                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27337                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27338                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27339                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27340                 false,
27341         },
27342         {
27343                 "spoolss_DeletePrinterDriver",
27344                 sizeof(struct spoolss_DeletePrinterDriver),
27345                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27346                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27347                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27348                 false,
27349         },
27350         {
27351                 "spoolss_AddPrintProcessor",
27352                 sizeof(struct spoolss_AddPrintProcessor),
27353                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27354                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27355                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27356                 false,
27357         },
27358         {
27359                 "spoolss_EnumPrintProcessors",
27360                 sizeof(struct spoolss_EnumPrintProcessors),
27361                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27362                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27363                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27364                 false,
27365         },
27366         {
27367                 "spoolss_GetPrintProcessorDirectory",
27368                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27369                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27370                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27371                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27372                 false,
27373         },
27374         {
27375                 "spoolss_StartDocPrinter",
27376                 sizeof(struct spoolss_StartDocPrinter),
27377                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27378                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27379                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27380                 false,
27381         },
27382         {
27383                 "spoolss_StartPagePrinter",
27384                 sizeof(struct spoolss_StartPagePrinter),
27385                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27386                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27387                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27388                 false,
27389         },
27390         {
27391                 "spoolss_WritePrinter",
27392                 sizeof(struct spoolss_WritePrinter),
27393                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27394                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27395                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27396                 false,
27397         },
27398         {
27399                 "spoolss_EndPagePrinter",
27400                 sizeof(struct spoolss_EndPagePrinter),
27401                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27402                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27403                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27404                 false,
27405         },
27406         {
27407                 "spoolss_AbortPrinter",
27408                 sizeof(struct spoolss_AbortPrinter),
27409                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27410                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27411                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27412                 false,
27413         },
27414         {
27415                 "spoolss_ReadPrinter",
27416                 sizeof(struct spoolss_ReadPrinter),
27417                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27418                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27419                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27420                 false,
27421         },
27422         {
27423                 "spoolss_EndDocPrinter",
27424                 sizeof(struct spoolss_EndDocPrinter),
27425                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27426                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27427                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27428                 false,
27429         },
27430         {
27431                 "spoolss_AddJob",
27432                 sizeof(struct spoolss_AddJob),
27433                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27434                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27435                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27436                 false,
27437         },
27438         {
27439                 "spoolss_ScheduleJob",
27440                 sizeof(struct spoolss_ScheduleJob),
27441                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27442                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27443                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27444                 false,
27445         },
27446         {
27447                 "spoolss_GetPrinterData",
27448                 sizeof(struct spoolss_GetPrinterData),
27449                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27450                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27451                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27452                 false,
27453         },
27454         {
27455                 "spoolss_SetPrinterData",
27456                 sizeof(struct spoolss_SetPrinterData),
27457                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27458                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27459                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27460                 false,
27461         },
27462         {
27463                 "spoolss_WaitForPrinterChange",
27464                 sizeof(struct spoolss_WaitForPrinterChange),
27465                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27466                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27467                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27468                 false,
27469         },
27470         {
27471                 "spoolss_ClosePrinter",
27472                 sizeof(struct spoolss_ClosePrinter),
27473                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27474                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27475                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27476                 false,
27477         },
27478         {
27479                 "spoolss_AddForm",
27480                 sizeof(struct spoolss_AddForm),
27481                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27482                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27483                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27484                 false,
27485         },
27486         {
27487                 "spoolss_DeleteForm",
27488                 sizeof(struct spoolss_DeleteForm),
27489                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27490                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27491                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27492                 false,
27493         },
27494         {
27495                 "spoolss_GetForm",
27496                 sizeof(struct spoolss_GetForm),
27497                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27498                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27499                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27500                 false,
27501         },
27502         {
27503                 "spoolss_SetForm",
27504                 sizeof(struct spoolss_SetForm),
27505                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27506                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27507                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27508                 false,
27509         },
27510         {
27511                 "spoolss_EnumForms",
27512                 sizeof(struct spoolss_EnumForms),
27513                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27514                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27515                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27516                 false,
27517         },
27518         {
27519                 "spoolss_EnumPorts",
27520                 sizeof(struct spoolss_EnumPorts),
27521                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27522                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27523                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27524                 false,
27525         },
27526         {
27527                 "spoolss_EnumMonitors",
27528                 sizeof(struct spoolss_EnumMonitors),
27529                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27530                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27531                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27532                 false,
27533         },
27534         {
27535                 "spoolss_AddPort",
27536                 sizeof(struct spoolss_AddPort),
27537                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27538                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27539                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27540                 false,
27541         },
27542         {
27543                 "spoolss_ConfigurePort",
27544                 sizeof(struct spoolss_ConfigurePort),
27545                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27546                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27547                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27548                 false,
27549         },
27550         {
27551                 "spoolss_DeletePort",
27552                 sizeof(struct spoolss_DeletePort),
27553                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27554                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27555                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27556                 false,
27557         },
27558         {
27559                 "spoolss_CreatePrinterIC",
27560                 sizeof(struct spoolss_CreatePrinterIC),
27561                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27562                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27563                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27564                 false,
27565         },
27566         {
27567                 "spoolss_PlayGDIScriptOnPrinterIC",
27568                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27569                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27570                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27571                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27572                 false,
27573         },
27574         {
27575                 "spoolss_DeletePrinterIC",
27576                 sizeof(struct spoolss_DeletePrinterIC),
27577                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27578                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27579                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27580                 false,
27581         },
27582         {
27583                 "spoolss_AddPrinterConnection",
27584                 sizeof(struct spoolss_AddPrinterConnection),
27585                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27586                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27587                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27588                 false,
27589         },
27590         {
27591                 "spoolss_DeletePrinterConnection",
27592                 sizeof(struct spoolss_DeletePrinterConnection),
27593                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27594                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27595                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27596                 false,
27597         },
27598         {
27599                 "spoolss_PrinterMessageBox",
27600                 sizeof(struct spoolss_PrinterMessageBox),
27601                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27602                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27603                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27604                 false,
27605         },
27606         {
27607                 "spoolss_AddMonitor",
27608                 sizeof(struct spoolss_AddMonitor),
27609                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27610                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27611                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27612                 false,
27613         },
27614         {
27615                 "spoolss_DeleteMonitor",
27616                 sizeof(struct spoolss_DeleteMonitor),
27617                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27618                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27619                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27620                 false,
27621         },
27622         {
27623                 "spoolss_DeletePrintProcessor",
27624                 sizeof(struct spoolss_DeletePrintProcessor),
27625                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27626                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27627                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27628                 false,
27629         },
27630         {
27631                 "spoolss_AddPrintProvidor",
27632                 sizeof(struct spoolss_AddPrintProvidor),
27633                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27634                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27635                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27636                 false,
27637         },
27638         {
27639                 "spoolss_DeletePrintProvidor",
27640                 sizeof(struct spoolss_DeletePrintProvidor),
27641                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27642                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27643                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27644                 false,
27645         },
27646         {
27647                 "spoolss_EnumPrintProcDataTypes",
27648                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27649                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27650                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27651                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27652                 false,
27653         },
27654         {
27655                 "spoolss_ResetPrinter",
27656                 sizeof(struct spoolss_ResetPrinter),
27657                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27658                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27659                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27660                 false,
27661         },
27662         {
27663                 "spoolss_GetPrinterDriver2",
27664                 sizeof(struct spoolss_GetPrinterDriver2),
27665                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27666                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27667                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27668                 false,
27669         },
27670         {
27671                 "spoolss_FindFirstPrinterChangeNotification",
27672                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27673                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27674                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27675                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27676                 false,
27677         },
27678         {
27679                 "spoolss_FindNextPrinterChangeNotification",
27680                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27681                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27682                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27683                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27684                 false,
27685         },
27686         {
27687                 "spoolss_FindClosePrinterNotify",
27688                 sizeof(struct spoolss_FindClosePrinterNotify),
27689                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27690                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27691                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27692                 false,
27693         },
27694         {
27695                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27696                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27697                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27698                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27699                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27700                 false,
27701         },
27702         {
27703                 "spoolss_ReplyOpenPrinter",
27704                 sizeof(struct spoolss_ReplyOpenPrinter),
27705                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27706                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27707                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
27708                 false,
27709         },
27710         {
27711                 "spoolss_RouterReplyPrinter",
27712                 sizeof(struct spoolss_RouterReplyPrinter),
27713                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
27714                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
27715                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
27716                 false,
27717         },
27718         {
27719                 "spoolss_ReplyClosePrinter",
27720                 sizeof(struct spoolss_ReplyClosePrinter),
27721                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
27722                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
27723                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
27724                 false,
27725         },
27726         {
27727                 "spoolss_AddPortEx",
27728                 sizeof(struct spoolss_AddPortEx),
27729                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
27730                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
27731                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
27732                 false,
27733         },
27734         {
27735                 "spoolss_RouterFindFirstPrinterChangeNotification",
27736                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
27737                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
27738                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
27739                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
27740                 false,
27741         },
27742         {
27743                 "spoolss_SpoolerInit",
27744                 sizeof(struct spoolss_SpoolerInit),
27745                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
27746                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
27747                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
27748                 false,
27749         },
27750         {
27751                 "spoolss_ResetPrinterEx",
27752                 sizeof(struct spoolss_ResetPrinterEx),
27753                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
27754                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
27755                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
27756                 false,
27757         },
27758         {
27759                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
27760                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
27761                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27762                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27763                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27764                 false,
27765         },
27766         {
27767                 "spoolss_RouterReplyPrinterEx",
27768                 sizeof(struct spoolss_RouterReplyPrinterEx),
27769                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
27770                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
27771                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
27772                 false,
27773         },
27774         {
27775                 "spoolss_RouterRefreshPrinterChangeNotify",
27776                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
27777                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
27778                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
27779                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
27780                 false,
27781         },
27782         {
27783                 "spoolss_44",
27784                 sizeof(struct spoolss_44),
27785                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
27786                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
27787                 (ndr_print_function_t) ndr_print_spoolss_44,
27788                 false,
27789         },
27790         {
27791                 "spoolss_OpenPrinterEx",
27792                 sizeof(struct spoolss_OpenPrinterEx),
27793                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
27794                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
27795                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
27796                 false,
27797         },
27798         {
27799                 "spoolss_AddPrinterEx",
27800                 sizeof(struct spoolss_AddPrinterEx),
27801                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
27802                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
27803                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
27804                 false,
27805         },
27806         {
27807                 "spoolss_47",
27808                 sizeof(struct spoolss_47),
27809                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
27810                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
27811                 (ndr_print_function_t) ndr_print_spoolss_47,
27812                 false,
27813         },
27814         {
27815                 "spoolss_EnumPrinterData",
27816                 sizeof(struct spoolss_EnumPrinterData),
27817                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
27818                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
27819                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
27820                 false,
27821         },
27822         {
27823                 "spoolss_DeletePrinterData",
27824                 sizeof(struct spoolss_DeletePrinterData),
27825                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
27826                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
27827                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
27828                 false,
27829         },
27830         {
27831                 "spoolss_4a",
27832                 sizeof(struct spoolss_4a),
27833                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
27834                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
27835                 (ndr_print_function_t) ndr_print_spoolss_4a,
27836                 false,
27837         },
27838         {
27839                 "spoolss_4b",
27840                 sizeof(struct spoolss_4b),
27841                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
27842                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
27843                 (ndr_print_function_t) ndr_print_spoolss_4b,
27844                 false,
27845         },
27846         {
27847                 "spoolss_4c",
27848                 sizeof(struct spoolss_4c),
27849                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
27850                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
27851                 (ndr_print_function_t) ndr_print_spoolss_4c,
27852                 false,
27853         },
27854         {
27855                 "spoolss_SetPrinterDataEx",
27856                 sizeof(struct spoolss_SetPrinterDataEx),
27857                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
27858                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
27859                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
27860                 false,
27861         },
27862         {
27863                 "spoolss_GetPrinterDataEx",
27864                 sizeof(struct spoolss_GetPrinterDataEx),
27865                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
27866                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
27867                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
27868                 false,
27869         },
27870         {
27871                 "spoolss_EnumPrinterDataEx",
27872                 sizeof(struct spoolss_EnumPrinterDataEx),
27873                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
27874                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
27875                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
27876                 false,
27877         },
27878         {
27879                 "spoolss_EnumPrinterKey",
27880                 sizeof(struct spoolss_EnumPrinterKey),
27881                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
27882                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
27883                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
27884                 false,
27885         },
27886         {
27887                 "spoolss_DeletePrinterDataEx",
27888                 sizeof(struct spoolss_DeletePrinterDataEx),
27889                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
27890                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
27891                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
27892                 false,
27893         },
27894         {
27895                 "spoolss_DeletePrinterKey",
27896                 sizeof(struct spoolss_DeletePrinterKey),
27897                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
27898                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
27899                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
27900                 false,
27901         },
27902         {
27903                 "spoolss_53",
27904                 sizeof(struct spoolss_53),
27905                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
27906                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
27907                 (ndr_print_function_t) ndr_print_spoolss_53,
27908                 false,
27909         },
27910         {
27911                 "spoolss_DeletePrinterDriverEx",
27912                 sizeof(struct spoolss_DeletePrinterDriverEx),
27913                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
27914                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
27915                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
27916                 false,
27917         },
27918         {
27919                 "spoolss_55",
27920                 sizeof(struct spoolss_55),
27921                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
27922                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
27923                 (ndr_print_function_t) ndr_print_spoolss_55,
27924                 false,
27925         },
27926         {
27927                 "spoolss_56",
27928                 sizeof(struct spoolss_56),
27929                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
27930                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
27931                 (ndr_print_function_t) ndr_print_spoolss_56,
27932                 false,
27933         },
27934         {
27935                 "spoolss_57",
27936                 sizeof(struct spoolss_57),
27937                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
27938                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
27939                 (ndr_print_function_t) ndr_print_spoolss_57,
27940                 false,
27941         },
27942         {
27943                 "spoolss_XcvData",
27944                 sizeof(struct spoolss_XcvData),
27945                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
27946                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
27947                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
27948                 false,
27949         },
27950         {
27951                 "spoolss_AddPrinterDriverEx",
27952                 sizeof(struct spoolss_AddPrinterDriverEx),
27953                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
27954                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
27955                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
27956                 false,
27957         },
27958         {
27959                 "spoolss_5a",
27960                 sizeof(struct spoolss_5a),
27961                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
27962                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
27963                 (ndr_print_function_t) ndr_print_spoolss_5a,
27964                 false,
27965         },
27966         {
27967                 "spoolss_5b",
27968                 sizeof(struct spoolss_5b),
27969                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
27970                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
27971                 (ndr_print_function_t) ndr_print_spoolss_5b,
27972                 false,
27973         },
27974         {
27975                 "spoolss_5c",
27976                 sizeof(struct spoolss_5c),
27977                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
27978                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
27979                 (ndr_print_function_t) ndr_print_spoolss_5c,
27980                 false,
27981         },
27982         {
27983                 "spoolss_5d",
27984                 sizeof(struct spoolss_5d),
27985                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
27986                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
27987                 (ndr_print_function_t) ndr_print_spoolss_5d,
27988                 false,
27989         },
27990         {
27991                 "spoolss_5e",
27992                 sizeof(struct spoolss_5e),
27993                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
27994                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
27995                 (ndr_print_function_t) ndr_print_spoolss_5e,
27996                 false,
27997         },
27998         {
27999                 "spoolss_5f",
28000                 sizeof(struct spoolss_5f),
28001                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28002                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28003                 (ndr_print_function_t) ndr_print_spoolss_5f,
28004                 false,
28005         },
28006         { NULL, 0, NULL, NULL, NULL, false }
28007 };
28008
28009 static const char * const spoolss_endpoint_strings[] = {
28010         "ncacn_np:[\\pipe\\spoolss]",
28011 };
28012
28013 static const struct ndr_interface_string_array spoolss_endpoints = {
28014         .count  = 1,
28015         .names  = spoolss_endpoint_strings
28016 };
28017
28018 static const char * const spoolss_authservice_strings[] = {
28019         "host",
28020 };
28021
28022 static const struct ndr_interface_string_array spoolss_authservices = {
28023         .count  = 1,
28024         .names  = spoolss_authservice_strings
28025 };
28026
28027
28028 const struct ndr_interface_table ndr_table_spoolss = {
28029         .name           = "spoolss",
28030         .syntax_id      = {
28031                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28032                 NDR_SPOOLSS_VERSION
28033         },
28034         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28035         .num_calls      = 96,
28036         .calls          = spoolss_calls,
28037         .endpoints      = &spoolss_endpoints,
28038         .authservices   = &spoolss_authservices
28039 };
28040