librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 4));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 516 {
 517         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 518 }
 519
 520 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 521 {
 522         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 527 {
 528         uint32_t v;
 529         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 530         *r = v;
 531         return NDR_ERR_SUCCESS;
 532 }
 533
 534 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 535 {
 536         ndr_print_uint32(ndr, name, r);
 537         ndr->depth++;
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 566         ndr->depth--;
 567 }
 568
 569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 570 {
 571         if (ndr_flags & NDR_SCALARS) {
 572                 NDR_CHECK(ndr_push_align(ndr, 4));
 573                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 578                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 587                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 589                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 590                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 591                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 592                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 593                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 607                 {
 608                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 610                         {
 611                                 struct ndr_push *_ndr_driverextra_data;
 612                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 613                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 614                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 615                         }
 616                         ndr->flags = _flags_save_DATA_BLOB;
 617                 }
 618         }
 619         if (ndr_flags & NDR_BUFFERS) {
 620         }
 621         return NDR_ERR_SUCCESS;
 622 }
 623
 624 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 625 {
 626         if (ndr_flags & NDR_SCALARS) {
 627                 NDR_CHECK(ndr_pull_align(ndr, 4));
 628                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 633                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 642                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 644                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 645                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 646                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 647                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 648                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 662                 {
 663                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 665                         {
 666                                 struct ndr_pull *_ndr_driverextra_data;
 667                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 668                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 669                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 670                         }
 671                         ndr->flags = _flags_save_DATA_BLOB;
 672                 }
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675         }
 676         return NDR_ERR_SUCCESS;
 677 }
 678
 679 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 680 {
 681         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 682         ndr->depth++;
 683         ndr_print_string(ndr, "devicename", r->devicename);
 684         ndr_print_uint16(ndr, "specversion", r->specversion);
 685         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 686         ndr_print_uint16(ndr, "size", r->size);
 687         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 688         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 689         ndr_print_uint16(ndr, "orientation", r->orientation);
 690         ndr_print_uint16(ndr, "papersize", r->papersize);
 691         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 692         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 693         ndr_print_uint16(ndr, "scale", r->scale);
 694         ndr_print_uint16(ndr, "copies", r->copies);
 695         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 696         ndr_print_uint16(ndr, "printquality", r->printquality);
 697         ndr_print_uint16(ndr, "color", r->color);
 698         ndr_print_uint16(ndr, "duplex", r->duplex);
 699         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 700         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 701         ndr_print_uint16(ndr, "collate", r->collate);
 702         ndr_print_string(ndr, "formname", r->formname);
 703         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 704         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 705         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 706         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 707         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 708         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 709         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 710         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 711         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 712         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 713         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 714         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 715         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 716         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 717         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 718         ndr->depth--;
 719 }
 720
 721 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 722 {
 723         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 724 }
 725
 726 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 727 {
 728         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 729         return NDR_ERR_SUCCESS;
 730 }
 731
 732 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 733 {
 734         uint32_t v;
 735         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 736         *r = v;
 737         return NDR_ERR_SUCCESS;
 738 }
 739
 740 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 741 {
 742         ndr_print_uint32(ndr, name, r);
 743         ndr->depth++;
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 759         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 763         ndr->depth--;
 764 }
 765
 766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_push_align(ndr, 4));
 770                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 771                 {
 772                         uint32_t _flags_save_string = ndr->flags;
 773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 774                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 775                         ndr->flags = _flags_save_string;
 776                 }
 777                 {
 778                         uint32_t _flags_save_string = ndr->flags;
 779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 780                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 781                         ndr->flags = _flags_save_string;
 782                 }
 783                 {
 784                         uint32_t _flags_save_string = ndr->flags;
 785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 786                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 787                         ndr->flags = _flags_save_string;
 788                 }
 789         }
 790         if (ndr_flags & NDR_BUFFERS) {
 791                 {
 792                         uint32_t _flags_save_string = ndr->flags;
 793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 794                         if (r->description) {
 795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 797                         }
 798                         ndr->flags = _flags_save_string;
 799                 }
 800                 {
 801                         uint32_t _flags_save_string = ndr->flags;
 802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 803                         if (r->name) {
 804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 806                         }
 807                         ndr->flags = _flags_save_string;
 808                 }
 809                 {
 810                         uint32_t _flags_save_string = ndr->flags;
 811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 812                         if (r->comment) {
 813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 814                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 815                         }
 816                         ndr->flags = _flags_save_string;
 817                 }
 818         }
 819         return NDR_ERR_SUCCESS;
 820 }
 821
 822 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 823 {
 824         uint32_t _ptr_description;
 825         TALLOC_CTX *_mem_save_description_0;
 826         uint32_t _ptr_name;
 827         TALLOC_CTX *_mem_save_name_0;
 828         uint32_t _ptr_comment;
 829         TALLOC_CTX *_mem_save_comment_0;
 830         if (ndr_flags & NDR_SCALARS) {
 831                 NDR_CHECK(ndr_pull_align(ndr, 4));
 832                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 833                 {
 834                         uint32_t _flags_save_string = ndr->flags;
 835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 837                         if (_ptr_description) {
 838                                 NDR_PULL_ALLOC(ndr, r->description);
 839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 840                         } else {
 841                                 r->description = NULL;
 842                         }
 843                         ndr->flags = _flags_save_string;
 844                 }
 845                 {
 846                         uint32_t _flags_save_string = ndr->flags;
 847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 849                         if (_ptr_name) {
 850                                 NDR_PULL_ALLOC(ndr, r->name);
 851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 852                         } else {
 853                                 r->name = NULL;
 854                         }
 855                         ndr->flags = _flags_save_string;
 856                 }
 857                 {
 858                         uint32_t _flags_save_string = ndr->flags;
 859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 861                         if (_ptr_comment) {
 862                                 NDR_PULL_ALLOC(ndr, r->comment);
 863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 864                         } else {
 865                                 r->comment = NULL;
 866                         }
 867                         ndr->flags = _flags_save_string;
 868                 }
 869         }
 870         if (ndr_flags & NDR_BUFFERS) {
 871                 {
 872                         uint32_t _flags_save_string = ndr->flags;
 873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 874                         if (r->description) {
 875                                 uint32_t _relative_save_offset;
 876                                 _relative_save_offset = ndr->offset;
 877                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 878                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 879                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 880                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 881                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 882                                 ndr->offset = _relative_save_offset;
 883                         }
 884                         ndr->flags = _flags_save_string;
 885                 }
 886                 {
 887                         uint32_t _flags_save_string = ndr->flags;
 888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 889                         if (r->name) {
 890                                 uint32_t _relative_save_offset;
 891                                 _relative_save_offset = ndr->offset;
 892                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 893                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 894                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 895                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 896                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 897                                 ndr->offset = _relative_save_offset;
 898                         }
 899                         ndr->flags = _flags_save_string;
 900                 }
 901                 {
 902                         uint32_t _flags_save_string = ndr->flags;
 903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 904                         if (r->comment) {
 905                                 uint32_t _relative_save_offset;
 906                                 _relative_save_offset = ndr->offset;
 907                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 908                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 909                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 910                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 911                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 912                                 ndr->offset = _relative_save_offset;
 913                         }
 914                         ndr->flags = _flags_save_string;
 915                 }
 916         }
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 921 {
 922         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 923         ndr->depth++;
 924         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 925         ndr_print_ptr(ndr, "description", r->description);
 926         ndr->depth++;
 927         if (r->description) {
 928                 ndr_print_string(ndr, "description", r->description);
 929         }
 930         ndr->depth--;
 931         ndr_print_ptr(ndr, "name", r->name);
 932         ndr->depth++;
 933         if (r->name) {
 934                 ndr_print_string(ndr, "name", r->name);
 935         }
 936         ndr->depth--;
 937         ndr_print_ptr(ndr, "comment", r->comment);
 938         ndr->depth++;
 939         if (r->comment) {
 940                 ndr_print_string(ndr, "comment", r->comment);
 941         }
 942         ndr->depth--;
 943         ndr->depth--;
 944 }
 945
 946 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
 947 {
 948         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
 949 }
 950
 951 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 952 {
 953         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 958 {
 959         uint32_t v;
 960         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 961         *r = v;
 962         return NDR_ERR_SUCCESS;
 963 }
 964
 965 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 966 {
 967         ndr_print_uint32(ndr, name, r);
 968         ndr->depth++;
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 985         ndr->depth--;
 986 }
 987
 988 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 989 {
 990         if (ndr_flags & NDR_SCALARS) {
 991                 NDR_CHECK(ndr_push_align(ndr, 4));
 992                 {
 993                         uint32_t _flags_save_string = ndr->flags;
 994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 996                         ndr->flags = _flags_save_string;
 997                 }
 998                 {
 999                         uint32_t _flags_save_string = ndr->flags;
1000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1002                         ndr->flags = _flags_save_string;
1003                 }
1004                 {
1005                         uint32_t _flags_save_string = ndr->flags;
1006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1008                         ndr->flags = _flags_save_string;
1009                 }
1010                 {
1011                         uint32_t _flags_save_string = ndr->flags;
1012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1014                         ndr->flags = _flags_save_string;
1015                 }
1016                 {
1017                         uint32_t _flags_save_string = ndr->flags;
1018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1020                         ndr->flags = _flags_save_string;
1021                 }
1022                 {
1023                         uint32_t _flags_save_string = ndr->flags;
1024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1026                         ndr->flags = _flags_save_string;
1027                 }
1028                 {
1029                         uint32_t _flags_save_string = ndr->flags;
1030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1031                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1032                         ndr->flags = _flags_save_string;
1033                 }
1034                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1039                         ndr->flags = _flags_save_string;
1040                 }
1041                 {
1042                         uint32_t _flags_save_string = ndr->flags;
1043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1045                         ndr->flags = _flags_save_string;
1046                 }
1047                 {
1048                         uint32_t _flags_save_string = ndr->flags;
1049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1057                         ndr->flags = _flags_save_string;
1058                 }
1059                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1060                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1065                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1068         }
1069         if (ndr_flags & NDR_BUFFERS) {
1070                 {
1071                         uint32_t _flags_save_string = ndr->flags;
1072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1073                         if (r->servername) {
1074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1076                         }
1077                         ndr->flags = _flags_save_string;
1078                 }
1079                 {
1080                         uint32_t _flags_save_string = ndr->flags;
1081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1082                         if (r->printername) {
1083                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1085                         }
1086                         ndr->flags = _flags_save_string;
1087                 }
1088                 {
1089                         uint32_t _flags_save_string = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1091                         if (r->sharename) {
1092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1094                         }
1095                         ndr->flags = _flags_save_string;
1096                 }
1097                 {
1098                         uint32_t _flags_save_string = ndr->flags;
1099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1100                         if (r->portname) {
1101                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1103                         }
1104                         ndr->flags = _flags_save_string;
1105                 }
1106                 {
1107                         uint32_t _flags_save_string = ndr->flags;
1108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1109                         if (r->drivername) {
1110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1112                         }
1113                         ndr->flags = _flags_save_string;
1114                 }
1115                 {
1116                         uint32_t _flags_save_string = ndr->flags;
1117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1118                         if (r->comment) {
1119                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1120                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1121                         }
1122                         ndr->flags = _flags_save_string;
1123                 }
1124                 {
1125                         uint32_t _flags_save_string = ndr->flags;
1126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1127                         if (r->location) {
1128                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1129                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1130                         }
1131                         ndr->flags = _flags_save_string;
1132                 }
1133                 if (r->devmode) {
1134                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1135                         {
1136                                 struct ndr_push *_ndr_devmode;
1137                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1138                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1139                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1140                         }
1141                 }
1142                 {
1143                         uint32_t _flags_save_string = ndr->flags;
1144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1145                         if (r->sepfile) {
1146                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1147                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1148                         }
1149                         ndr->flags = _flags_save_string;
1150                 }
1151                 {
1152                         uint32_t _flags_save_string = ndr->flags;
1153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1154                         if (r->printprocessor) {
1155                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1156                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1157                         }
1158                         ndr->flags = _flags_save_string;
1159                 }
1160                 {
1161                         uint32_t _flags_save_string = ndr->flags;
1162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1163                         if (r->datatype) {
1164                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1165                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1166                         }
1167                         ndr->flags = _flags_save_string;
1168                 }
1169                 {
1170                         uint32_t _flags_save_string = ndr->flags;
1171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1172                         if (r->parameters) {
1173                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1174                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1175                         }
1176                         ndr->flags = _flags_save_string;
1177                 }
1178                 if (r->secdesc) {
1179                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1180                         {
1181                                 struct ndr_push *_ndr_secdesc;
1182                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1183                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1184                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1185                         }
1186                 }
1187         }
1188         return NDR_ERR_SUCCESS;
1189 }
1190
1191 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1192 {
1193         uint32_t _ptr_servername;
1194         TALLOC_CTX *_mem_save_servername_0;
1195         uint32_t _ptr_printername;
1196         TALLOC_CTX *_mem_save_printername_0;
1197         uint32_t _ptr_sharename;
1198         TALLOC_CTX *_mem_save_sharename_0;
1199         uint32_t _ptr_portname;
1200         TALLOC_CTX *_mem_save_portname_0;
1201         uint32_t _ptr_drivername;
1202         TALLOC_CTX *_mem_save_drivername_0;
1203         uint32_t _ptr_comment;
1204         TALLOC_CTX *_mem_save_comment_0;
1205         uint32_t _ptr_location;
1206         TALLOC_CTX *_mem_save_location_0;
1207         uint32_t _ptr_devmode;
1208         TALLOC_CTX *_mem_save_devmode_0;
1209         uint32_t _ptr_sepfile;
1210         TALLOC_CTX *_mem_save_sepfile_0;
1211         uint32_t _ptr_printprocessor;
1212         TALLOC_CTX *_mem_save_printprocessor_0;
1213         uint32_t _ptr_datatype;
1214         TALLOC_CTX *_mem_save_datatype_0;
1215         uint32_t _ptr_parameters;
1216         TALLOC_CTX *_mem_save_parameters_0;
1217         uint32_t _ptr_secdesc;
1218         TALLOC_CTX *_mem_save_secdesc_0;
1219         if (ndr_flags & NDR_SCALARS) {
1220                 NDR_CHECK(ndr_pull_align(ndr, 4));
1221                 {
1222                         uint32_t _flags_save_string = ndr->flags;
1223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1225                         if (_ptr_servername) {
1226                                 NDR_PULL_ALLOC(ndr, r->servername);
1227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1228                         } else {
1229                                 r->servername = NULL;
1230                         }
1231                         ndr->flags = _flags_save_string;
1232                 }
1233                 {
1234                         uint32_t _flags_save_string = ndr->flags;
1235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1237                         if (_ptr_printername) {
1238                                 NDR_PULL_ALLOC(ndr, r->printername);
1239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1240                         } else {
1241                                 r->printername = NULL;
1242                         }
1243                         ndr->flags = _flags_save_string;
1244                 }
1245                 {
1246                         uint32_t _flags_save_string = ndr->flags;
1247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1248                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1249                         if (_ptr_sharename) {
1250                                 NDR_PULL_ALLOC(ndr, r->sharename);
1251                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1252                         } else {
1253                                 r->sharename = NULL;
1254                         }
1255                         ndr->flags = _flags_save_string;
1256                 }
1257                 {
1258                         uint32_t _flags_save_string = ndr->flags;
1259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1260                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1261                         if (_ptr_portname) {
1262                                 NDR_PULL_ALLOC(ndr, r->portname);
1263                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1264                         } else {
1265                                 r->portname = NULL;
1266                         }
1267                         ndr->flags = _flags_save_string;
1268                 }
1269                 {
1270                         uint32_t _flags_save_string = ndr->flags;
1271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1273                         if (_ptr_drivername) {
1274                                 NDR_PULL_ALLOC(ndr, r->drivername);
1275                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1276                         } else {
1277                                 r->drivername = NULL;
1278                         }
1279                         ndr->flags = _flags_save_string;
1280                 }
1281                 {
1282                         uint32_t _flags_save_string = ndr->flags;
1283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1284                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1285                         if (_ptr_comment) {
1286                                 NDR_PULL_ALLOC(ndr, r->comment);
1287                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1288                         } else {
1289                                 r->comment = NULL;
1290                         }
1291                         ndr->flags = _flags_save_string;
1292                 }
1293                 {
1294                         uint32_t _flags_save_string = ndr->flags;
1295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1296                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1297                         if (_ptr_location) {
1298                                 NDR_PULL_ALLOC(ndr, r->location);
1299                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1300                         } else {
1301                                 r->location = NULL;
1302                         }
1303                         ndr->flags = _flags_save_string;
1304                 }
1305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1306                 if (_ptr_devmode) {
1307                         NDR_PULL_ALLOC(ndr, r->devmode);
1308                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1309                 } else {
1310                         r->devmode = NULL;
1311                 }
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1316                         if (_ptr_sepfile) {
1317                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1319                         } else {
1320                                 r->sepfile = NULL;
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324                 {
1325                         uint32_t _flags_save_string = ndr->flags;
1326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1327                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1328                         if (_ptr_printprocessor) {
1329                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1330                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1331                         } else {
1332                                 r->printprocessor = NULL;
1333                         }
1334                         ndr->flags = _flags_save_string;
1335                 }
1336                 {
1337                         uint32_t _flags_save_string = ndr->flags;
1338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1339                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1340                         if (_ptr_datatype) {
1341                                 NDR_PULL_ALLOC(ndr, r->datatype);
1342                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1343                         } else {
1344                                 r->datatype = NULL;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1352                         if (_ptr_parameters) {
1353                                 NDR_PULL_ALLOC(ndr, r->parameters);
1354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1355                         } else {
1356                                 r->parameters = NULL;
1357                         }
1358                         ndr->flags = _flags_save_string;
1359                 }
1360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1361                 if (_ptr_secdesc) {
1362                         NDR_PULL_ALLOC(ndr, r->secdesc);
1363                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1364                 } else {
1365                         r->secdesc = NULL;
1366                 }
1367                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1369                 if (r->priority > 99) {
1370                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1371                 }
1372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1375                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1378         }
1379         if (ndr_flags & NDR_BUFFERS) {
1380                 {
1381                         uint32_t _flags_save_string = ndr->flags;
1382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1383                         if (r->servername) {
1384                                 uint32_t _relative_save_offset;
1385                                 _relative_save_offset = ndr->offset;
1386                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1387                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1388                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1389                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1390                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1391                                 ndr->offset = _relative_save_offset;
1392                         }
1393                         ndr->flags = _flags_save_string;
1394                 }
1395                 {
1396                         uint32_t _flags_save_string = ndr->flags;
1397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1398                         if (r->printername) {
1399                                 uint32_t _relative_save_offset;
1400                                 _relative_save_offset = ndr->offset;
1401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1402                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1403                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1404                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1406                                 ndr->offset = _relative_save_offset;
1407                         }
1408                         ndr->flags = _flags_save_string;
1409                 }
1410                 {
1411                         uint32_t _flags_save_string = ndr->flags;
1412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1413                         if (r->sharename) {
1414                                 uint32_t _relative_save_offset;
1415                                 _relative_save_offset = ndr->offset;
1416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1417                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1418                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1421                                 ndr->offset = _relative_save_offset;
1422                         }
1423                         ndr->flags = _flags_save_string;
1424                 }
1425                 {
1426                         uint32_t _flags_save_string = ndr->flags;
1427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1428                         if (r->portname) {
1429                                 uint32_t _relative_save_offset;
1430                                 _relative_save_offset = ndr->offset;
1431                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1432                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1433                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1434                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1435                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1436                                 ndr->offset = _relative_save_offset;
1437                         }
1438                         ndr->flags = _flags_save_string;
1439                 }
1440                 {
1441                         uint32_t _flags_save_string = ndr->flags;
1442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1443                         if (r->drivername) {
1444                                 uint32_t _relative_save_offset;
1445                                 _relative_save_offset = ndr->offset;
1446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1447                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1448                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1451                                 ndr->offset = _relative_save_offset;
1452                         }
1453                         ndr->flags = _flags_save_string;
1454                 }
1455                 {
1456                         uint32_t _flags_save_string = ndr->flags;
1457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1458                         if (r->comment) {
1459                                 uint32_t _relative_save_offset;
1460                                 _relative_save_offset = ndr->offset;
1461                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1462                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1463                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1464                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1465                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1466                                 ndr->offset = _relative_save_offset;
1467                         }
1468                         ndr->flags = _flags_save_string;
1469                 }
1470                 {
1471                         uint32_t _flags_save_string = ndr->flags;
1472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1473                         if (r->location) {
1474                                 uint32_t _relative_save_offset;
1475                                 _relative_save_offset = ndr->offset;
1476                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1477                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1478                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1479                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1480                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1481                                 ndr->offset = _relative_save_offset;
1482                         }
1483                         ndr->flags = _flags_save_string;
1484                 }
1485                 if (r->devmode) {
1486                         uint32_t _relative_save_offset;
1487                         _relative_save_offset = ndr->offset;
1488                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1489                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1490                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1491                         {
1492                                 struct ndr_pull *_ndr_devmode;
1493                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1494                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1495                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1496                         }
1497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1498                         ndr->offset = _relative_save_offset;
1499                 }
1500                 {
1501                         uint32_t _flags_save_string = ndr->flags;
1502                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1503                         if (r->sepfile) {
1504                                 uint32_t _relative_save_offset;
1505                                 _relative_save_offset = ndr->offset;
1506                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1507                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1508                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1509                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1510                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1511                                 ndr->offset = _relative_save_offset;
1512                         }
1513                         ndr->flags = _flags_save_string;
1514                 }
1515                 {
1516                         uint32_t _flags_save_string = ndr->flags;
1517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1518                         if (r->printprocessor) {
1519                                 uint32_t _relative_save_offset;
1520                                 _relative_save_offset = ndr->offset;
1521                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1522                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1523                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1524                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1525                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1526                                 ndr->offset = _relative_save_offset;
1527                         }
1528                         ndr->flags = _flags_save_string;
1529                 }
1530                 {
1531                         uint32_t _flags_save_string = ndr->flags;
1532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1533                         if (r->datatype) {
1534                                 uint32_t _relative_save_offset;
1535                                 _relative_save_offset = ndr->offset;
1536                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1537                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1538                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1539                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1540                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1541                                 ndr->offset = _relative_save_offset;
1542                         }
1543                         ndr->flags = _flags_save_string;
1544                 }
1545                 {
1546                         uint32_t _flags_save_string = ndr->flags;
1547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1548                         if (r->parameters) {
1549                                 uint32_t _relative_save_offset;
1550                                 _relative_save_offset = ndr->offset;
1551                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1552                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1553                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1554                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1555                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1556                                 ndr->offset = _relative_save_offset;
1557                         }
1558                         ndr->flags = _flags_save_string;
1559                 }
1560                 if (r->secdesc) {
1561                         uint32_t _relative_save_offset;
1562                         _relative_save_offset = ndr->offset;
1563                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1564                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1565                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1566                         {
1567                                 struct ndr_pull *_ndr_secdesc;
1568                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1569                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1570                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1571                         }
1572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1573                         ndr->offset = _relative_save_offset;
1574                 }
1575         }
1576         return NDR_ERR_SUCCESS;
1577 }
1578
1579 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1580 {
1581         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1582         ndr->depth++;
1583         ndr_print_ptr(ndr, "servername", r->servername);
1584         ndr->depth++;
1585         if (r->servername) {
1586                 ndr_print_string(ndr, "servername", r->servername);
1587         }
1588         ndr->depth--;
1589         ndr_print_ptr(ndr, "printername", r->printername);
1590         ndr->depth++;
1591         if (r->printername) {
1592                 ndr_print_string(ndr, "printername", r->printername);
1593         }
1594         ndr->depth--;
1595         ndr_print_ptr(ndr, "sharename", r->sharename);
1596         ndr->depth++;
1597         if (r->sharename) {
1598                 ndr_print_string(ndr, "sharename", r->sharename);
1599         }
1600         ndr->depth--;
1601         ndr_print_ptr(ndr, "portname", r->portname);
1602         ndr->depth++;
1603         if (r->portname) {
1604                 ndr_print_string(ndr, "portname", r->portname);
1605         }
1606         ndr->depth--;
1607         ndr_print_ptr(ndr, "drivername", r->drivername);
1608         ndr->depth++;
1609         if (r->drivername) {
1610                 ndr_print_string(ndr, "drivername", r->drivername);
1611         }
1612         ndr->depth--;
1613         ndr_print_ptr(ndr, "comment", r->comment);
1614         ndr->depth++;
1615         if (r->comment) {
1616                 ndr_print_string(ndr, "comment", r->comment);
1617         }
1618         ndr->depth--;
1619         ndr_print_ptr(ndr, "location", r->location);
1620         ndr->depth++;
1621         if (r->location) {
1622                 ndr_print_string(ndr, "location", r->location);
1623         }
1624         ndr->depth--;
1625         ndr_print_ptr(ndr, "devmode", r->devmode);
1626         ndr->depth++;
1627         if (r->devmode) {
1628                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1629         }
1630         ndr->depth--;
1631         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1632         ndr->depth++;
1633         if (r->sepfile) {
1634                 ndr_print_string(ndr, "sepfile", r->sepfile);
1635         }
1636         ndr->depth--;
1637         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1638         ndr->depth++;
1639         if (r->printprocessor) {
1640                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1641         }
1642         ndr->depth--;
1643         ndr_print_ptr(ndr, "datatype", r->datatype);
1644         ndr->depth++;
1645         if (r->datatype) {
1646                 ndr_print_string(ndr, "datatype", r->datatype);
1647         }
1648         ndr->depth--;
1649         ndr_print_ptr(ndr, "parameters", r->parameters);
1650         ndr->depth++;
1651         if (r->parameters) {
1652                 ndr_print_string(ndr, "parameters", r->parameters);
1653         }
1654         ndr->depth--;
1655         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1656         ndr->depth++;
1657         if (r->secdesc) {
1658                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1659         }
1660         ndr->depth--;
1661         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1662         ndr_print_uint32(ndr, "priority", r->priority);
1663         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1664         ndr_print_uint32(ndr, "starttime", r->starttime);
1665         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1666         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1667         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1668         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1669         ndr->depth--;
1670 }
1671
1672 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
1673 {
1674         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
1675 }
1676
1677 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1678 {
1679         if (ndr_flags & NDR_SCALARS) {
1680                 NDR_CHECK(ndr_push_align(ndr, 4));
1681                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1682         }
1683         if (ndr_flags & NDR_BUFFERS) {
1684                 if (r->secdesc) {
1685                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1686                         {
1687                                 struct ndr_push *_ndr_secdesc;
1688                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1689                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1690                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1691                         }
1692                 }
1693         }
1694         return NDR_ERR_SUCCESS;
1695 }
1696
1697 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1698 {
1699         uint32_t _ptr_secdesc;
1700         TALLOC_CTX *_mem_save_secdesc_0;
1701         if (ndr_flags & NDR_SCALARS) {
1702                 NDR_CHECK(ndr_pull_align(ndr, 4));
1703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1704                 if (_ptr_secdesc) {
1705                         NDR_PULL_ALLOC(ndr, r->secdesc);
1706                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1707                 } else {
1708                         r->secdesc = NULL;
1709                 }
1710         }
1711         if (ndr_flags & NDR_BUFFERS) {
1712                 if (r->secdesc) {
1713                         uint32_t _relative_save_offset;
1714                         _relative_save_offset = ndr->offset;
1715                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1716                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1717                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1718                         {
1719                                 struct ndr_pull *_ndr_secdesc;
1720                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1721                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1722                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1723                         }
1724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1725                         ndr->offset = _relative_save_offset;
1726                 }
1727         }
1728         return NDR_ERR_SUCCESS;
1729 }
1730
1731 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1732 {
1733         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1734         ndr->depth++;
1735         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1736         ndr->depth++;
1737         if (r->secdesc) {
1738                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1739         }
1740         ndr->depth--;
1741         ndr->depth--;
1742 }
1743
1744 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
1745 {
1746         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
1747 }
1748
1749 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1750 {
1751         if (ndr_flags & NDR_SCALARS) {
1752                 NDR_CHECK(ndr_push_align(ndr, 4));
1753                 {
1754                         uint32_t _flags_save_string = ndr->flags;
1755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1756                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1757                         ndr->flags = _flags_save_string;
1758                 }
1759                 {
1760                         uint32_t _flags_save_string = ndr->flags;
1761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1762                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1763                         ndr->flags = _flags_save_string;
1764                 }
1765                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 {
1769                         uint32_t _flags_save_string = ndr->flags;
1770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1771                         if (r->printername) {
1772                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1773                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1774                         }
1775                         ndr->flags = _flags_save_string;
1776                 }
1777                 {
1778                         uint32_t _flags_save_string = ndr->flags;
1779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1780                         if (r->servername) {
1781                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1783                         }
1784                         ndr->flags = _flags_save_string;
1785                 }
1786         }
1787         return NDR_ERR_SUCCESS;
1788 }
1789
1790 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1791 {
1792         uint32_t _ptr_printername;
1793         TALLOC_CTX *_mem_save_printername_0;
1794         uint32_t _ptr_servername;
1795         TALLOC_CTX *_mem_save_servername_0;
1796         if (ndr_flags & NDR_SCALARS) {
1797                 NDR_CHECK(ndr_pull_align(ndr, 4));
1798                 {
1799                         uint32_t _flags_save_string = ndr->flags;
1800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1801                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1802                         if (_ptr_printername) {
1803                                 NDR_PULL_ALLOC(ndr, r->printername);
1804                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1805                         } else {
1806                                 r->printername = NULL;
1807                         }
1808                         ndr->flags = _flags_save_string;
1809                 }
1810                 {
1811                         uint32_t _flags_save_string = ndr->flags;
1812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1813                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1814                         if (_ptr_servername) {
1815                                 NDR_PULL_ALLOC(ndr, r->servername);
1816                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1817                         } else {
1818                                 r->servername = NULL;
1819                         }
1820                         ndr->flags = _flags_save_string;
1821                 }
1822                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1823         }
1824         if (ndr_flags & NDR_BUFFERS) {
1825                 {
1826                         uint32_t _flags_save_string = ndr->flags;
1827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1828                         if (r->printername) {
1829                                 uint32_t _relative_save_offset;
1830                                 _relative_save_offset = ndr->offset;
1831                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1832                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1833                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1834                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1835                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1836                                 ndr->offset = _relative_save_offset;
1837                         }
1838                         ndr->flags = _flags_save_string;
1839                 }
1840                 {
1841                         uint32_t _flags_save_string = ndr->flags;
1842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1843                         if (r->servername) {
1844                                 uint32_t _relative_save_offset;
1845                                 _relative_save_offset = ndr->offset;
1846                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1847                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1848                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1849                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1850                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1851                                 ndr->offset = _relative_save_offset;
1852                         }
1853                         ndr->flags = _flags_save_string;
1854                 }
1855         }
1856         return NDR_ERR_SUCCESS;
1857 }
1858
1859 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1860 {
1861         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1862         ndr->depth++;
1863         ndr_print_ptr(ndr, "printername", r->printername);
1864         ndr->depth++;
1865         if (r->printername) {
1866                 ndr_print_string(ndr, "printername", r->printername);
1867         }
1868         ndr->depth--;
1869         ndr_print_ptr(ndr, "servername", r->servername);
1870         ndr->depth++;
1871         if (r->servername) {
1872                 ndr_print_string(ndr, "servername", r->servername);
1873         }
1874         ndr->depth--;
1875         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1876         ndr->depth--;
1877 }
1878
1879 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
1880 {
1881         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
1882 }
1883
1884 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1885 {
1886         if (ndr_flags & NDR_SCALARS) {
1887                 NDR_CHECK(ndr_push_align(ndr, 4));
1888                 {
1889                         uint32_t _flags_save_string = ndr->flags;
1890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1891                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1892                         ndr->flags = _flags_save_string;
1893                 }
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1898                         ndr->flags = _flags_save_string;
1899                 }
1900                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1903         }
1904         if (ndr_flags & NDR_BUFFERS) {
1905                 {
1906                         uint32_t _flags_save_string = ndr->flags;
1907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1908                         if (r->printername) {
1909                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1910                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1911                         }
1912                         ndr->flags = _flags_save_string;
1913                 }
1914                 {
1915                         uint32_t _flags_save_string = ndr->flags;
1916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1917                         if (r->portname) {
1918                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1919                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1920                         }
1921                         ndr->flags = _flags_save_string;
1922                 }
1923         }
1924         return NDR_ERR_SUCCESS;
1925 }
1926
1927 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1928 {
1929         uint32_t _ptr_printername;
1930         TALLOC_CTX *_mem_save_printername_0;
1931         uint32_t _ptr_portname;
1932         TALLOC_CTX *_mem_save_portname_0;
1933         if (ndr_flags & NDR_SCALARS) {
1934                 NDR_CHECK(ndr_pull_align(ndr, 4));
1935                 {
1936                         uint32_t _flags_save_string = ndr->flags;
1937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1938                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1939                         if (_ptr_printername) {
1940                                 NDR_PULL_ALLOC(ndr, r->printername);
1941                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1942                         } else {
1943                                 r->printername = NULL;
1944                         }
1945                         ndr->flags = _flags_save_string;
1946                 }
1947                 {
1948                         uint32_t _flags_save_string = ndr->flags;
1949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1951                         if (_ptr_portname) {
1952                                 NDR_PULL_ALLOC(ndr, r->portname);
1953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1954                         } else {
1955                                 r->portname = NULL;
1956                         }
1957                         ndr->flags = _flags_save_string;
1958                 }
1959                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1962         }
1963         if (ndr_flags & NDR_BUFFERS) {
1964                 {
1965                         uint32_t _flags_save_string = ndr->flags;
1966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1967                         if (r->printername) {
1968                                 uint32_t _relative_save_offset;
1969                                 _relative_save_offset = ndr->offset;
1970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1971                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1972                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1975                                 ndr->offset = _relative_save_offset;
1976                         }
1977                         ndr->flags = _flags_save_string;
1978                 }
1979                 {
1980                         uint32_t _flags_save_string = ndr->flags;
1981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1982                         if (r->portname) {
1983                                 uint32_t _relative_save_offset;
1984                                 _relative_save_offset = ndr->offset;
1985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1986                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1987                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1990                                 ndr->offset = _relative_save_offset;
1991                         }
1992                         ndr->flags = _flags_save_string;
1993                 }
1994         }
1995         return NDR_ERR_SUCCESS;
1996 }
1997
1998 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1999 {
2000         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2001         ndr->depth++;
2002         ndr_print_ptr(ndr, "printername", r->printername);
2003         ndr->depth++;
2004         if (r->printername) {
2005                 ndr_print_string(ndr, "printername", r->printername);
2006         }
2007         ndr->depth--;
2008         ndr_print_ptr(ndr, "portname", r->portname);
2009         ndr->depth++;
2010         if (r->portname) {
2011                 ndr_print_string(ndr, "portname", r->portname);
2012         }
2013         ndr->depth--;
2014         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2015         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2016         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2017         ndr->depth--;
2018 }
2019
2020 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2021 {
2022         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2023 }
2024
2025 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2026 {
2027         if (ndr_flags & NDR_SCALARS) {
2028                 NDR_CHECK(ndr_push_align(ndr, 4));
2029                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2030         }
2031         if (ndr_flags & NDR_BUFFERS) {
2032         }
2033         return NDR_ERR_SUCCESS;
2034 }
2035
2036 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2037 {
2038         if (ndr_flags & NDR_SCALARS) {
2039                 NDR_CHECK(ndr_pull_align(ndr, 4));
2040                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2041         }
2042         if (ndr_flags & NDR_BUFFERS) {
2043         }
2044         return NDR_ERR_SUCCESS;
2045 }
2046
2047 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2048 {
2049         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2050         ndr->depth++;
2051         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2052         ndr->depth--;
2053 }
2054
2055 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2056 {
2057         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2058 }
2059
2060 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2061 {
2062         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2063         return NDR_ERR_SUCCESS;
2064 }
2065
2066 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2067 {
2068         uint32_t v;
2069         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2070         *r = v;
2071         return NDR_ERR_SUCCESS;
2072 }
2073
2074 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2075 {
2076         ndr_print_uint32(ndr, name, r);
2077         ndr->depth++;
2078         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2079         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2080         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2081         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2082         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2083         ndr->depth--;
2084 }
2085
2086 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2087 {
2088         if (ndr_flags & NDR_SCALARS) {
2089                 NDR_CHECK(ndr_push_align(ndr, 4));
2090                 {
2091                         uint32_t _flags_save_string = ndr->flags;
2092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2093                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2094                         ndr->flags = _flags_save_string;
2095                 }
2096                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2097         }
2098         if (ndr_flags & NDR_BUFFERS) {
2099                 {
2100                         uint32_t _flags_save_string = ndr->flags;
2101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2102                         if (r->guid) {
2103                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2104                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2105                         }
2106                         ndr->flags = _flags_save_string;
2107                 }
2108         }
2109         return NDR_ERR_SUCCESS;
2110 }
2111
2112 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2113 {
2114         uint32_t _ptr_guid;
2115         TALLOC_CTX *_mem_save_guid_0;
2116         if (ndr_flags & NDR_SCALARS) {
2117                 NDR_CHECK(ndr_pull_align(ndr, 4));
2118                 {
2119                         uint32_t _flags_save_string = ndr->flags;
2120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2121                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2122                         if (_ptr_guid) {
2123                                 NDR_PULL_ALLOC(ndr, r->guid);
2124                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2125                         } else {
2126                                 r->guid = NULL;
2127                         }
2128                         ndr->flags = _flags_save_string;
2129                 }
2130                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2131         }
2132         if (ndr_flags & NDR_BUFFERS) {
2133                 {
2134                         uint32_t _flags_save_string = ndr->flags;
2135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2136                         if (r->guid) {
2137                                 uint32_t _relative_save_offset;
2138                                 _relative_save_offset = ndr->offset;
2139                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2140                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2141                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2142                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2143                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2144                                 ndr->offset = _relative_save_offset;
2145                         }
2146                         ndr->flags = _flags_save_string;
2147                 }
2148         }
2149         return NDR_ERR_SUCCESS;
2150 }
2151
2152 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2153 {
2154         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2155         ndr->depth++;
2156         ndr_print_ptr(ndr, "guid", r->guid);
2157         ndr->depth++;
2158         if (r->guid) {
2159                 ndr_print_string(ndr, "guid", r->guid);
2160         }
2161         ndr->depth--;
2162         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2163         ndr->depth--;
2164 }
2165
2166 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2167 {
2168         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2169 }
2170
2171 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2172 {
2173         if (ndr_flags & NDR_SCALARS) {
2174                 NDR_CHECK(ndr_push_align(ndr, 4));
2175                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2176         }
2177         if (ndr_flags & NDR_BUFFERS) {
2178                 if (r->devmode) {
2179                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2180                         {
2181                                 struct ndr_push *_ndr_devmode;
2182                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2183                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2184                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2185                         }
2186                 }
2187         }
2188         return NDR_ERR_SUCCESS;
2189 }
2190
2191 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2192 {
2193         uint32_t _ptr_devmode;
2194         TALLOC_CTX *_mem_save_devmode_0;
2195         if (ndr_flags & NDR_SCALARS) {
2196                 NDR_CHECK(ndr_pull_align(ndr, 4));
2197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2198                 if (_ptr_devmode) {
2199                         NDR_PULL_ALLOC(ndr, r->devmode);
2200                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2201                 } else {
2202                         r->devmode = NULL;
2203                 }
2204         }
2205         if (ndr_flags & NDR_BUFFERS) {
2206                 if (r->devmode) {
2207                         uint32_t _relative_save_offset;
2208                         _relative_save_offset = ndr->offset;
2209                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2210                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2211                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2212                         {
2213                                 struct ndr_pull *_ndr_devmode;
2214                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2215                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2216                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2217                         }
2218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2219                         ndr->offset = _relative_save_offset;
2220                 }
2221         }
2222         return NDR_ERR_SUCCESS;
2223 }
2224
2225 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2226 {
2227         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2228         ndr->depth++;
2229         ndr_print_ptr(ndr, "devmode", r->devmode);
2230         ndr->depth++;
2231         if (r->devmode) {
2232                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2233         }
2234         ndr->depth--;
2235         ndr->depth--;
2236 }
2237
2238 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2239 {
2240         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2241         if (ndr_flags & NDR_SCALARS) {
2242                 int level = ndr_push_get_switch_value(ndr, r);
2243                 switch (level) {
2244                         case 0: {
2245                                 NDR_CHECK(ndr_push_align(ndr, 4));
2246                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2247                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2248                         break; }
2249
2250                         case 1: {
2251                                 NDR_CHECK(ndr_push_align(ndr, 4));
2252                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2253                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2254                         break; }
2255
2256                         case 2: {
2257                                 NDR_CHECK(ndr_push_align(ndr, 4));
2258                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2259                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2260                         break; }
2261
2262                         case 3: {
2263                                 NDR_CHECK(ndr_push_align(ndr, 4));
2264                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2265                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2266                         break; }
2267
2268                         case 4: {
2269                                 NDR_CHECK(ndr_push_align(ndr, 4));
2270                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2271                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2272                         break; }
2273
2274                         case 5: {
2275                                 NDR_CHECK(ndr_push_align(ndr, 4));
2276                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2277                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2278                         break; }
2279
2280                         case 6: {
2281                                 NDR_CHECK(ndr_push_align(ndr, 4));
2282                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2283                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2284                         break; }
2285
2286                         case 7: {
2287                                 NDR_CHECK(ndr_push_align(ndr, 4));
2288                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2289                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2290                         break; }
2291
2292                         case 8: {
2293                                 NDR_CHECK(ndr_push_align(ndr, 4));
2294                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2295                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2296                         break; }
2297
2298                         case 9: {
2299                                 NDR_CHECK(ndr_push_align(ndr, 4));
2300                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2301                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2302                         break; }
2303
2304                         default: {
2305                         break; }
2306
2307                 }
2308         }
2309         if (ndr_flags & NDR_BUFFERS) {
2310                 int level = ndr_push_get_switch_value(ndr, r);
2311                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2312                 switch (level) {
2313                         case 0:
2314                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2315                         break;
2316
2317                         case 1:
2318                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2319                         break;
2320
2321                         case 2:
2322                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2323                         break;
2324
2325                         case 3:
2326                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2327                         break;
2328
2329                         case 4:
2330                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2331                         break;
2332
2333                         case 5:
2334                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2335                         break;
2336
2337                         case 6:
2338                         break;
2339
2340                         case 7:
2341                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2342                         break;
2343
2344                         case 8:
2345                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2346                         break;
2347
2348                         case 9:
2349                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2350                         break;
2351
2352                         default:
2353                         break;
2354
2355                 }
2356         }
2357         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2358         return NDR_ERR_SUCCESS;
2359 }
2360
2361 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2362 {
2363         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2364         int level;
2365         level = ndr_pull_get_switch_value(ndr, r);
2366         if (ndr_flags & NDR_SCALARS) {
2367                 switch (level) {
2368                         case 0: {
2369                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2370                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2371                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2372                         break; }
2373
2374                         case 1: {
2375                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2376                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2377                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2378                         break; }
2379
2380                         case 2: {
2381                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2382                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2383                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2384                         break; }
2385
2386                         case 3: {
2387                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2388                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2389                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2390                         break; }
2391
2392                         case 4: {
2393                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2394                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2395                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2396                         break; }
2397
2398                         case 5: {
2399                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2400                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2401                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2402                         break; }
2403
2404                         case 6: {
2405                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2406                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2407                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2408                         break; }
2409
2410                         case 7: {
2411                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2412                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2413                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2414                         break; }
2415
2416                         case 8: {
2417                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2418                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2419                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2420                         break; }
2421
2422                         case 9: {
2423                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2424                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2425                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2426                         break; }
2427
2428                         default: {
2429                         break; }
2430
2431                 }
2432         }
2433         if (ndr_flags & NDR_BUFFERS) {
2434                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2435                 switch (level) {
2436                         case 0:
2437                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2438                         break;
2439
2440                         case 1:
2441                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2442                         break;
2443
2444                         case 2:
2445                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2446                         break;
2447
2448                         case 3:
2449                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2450                         break;
2451
2452                         case 4:
2453                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2454                         break;
2455
2456                         case 5:
2457                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2458                         break;
2459
2460                         case 6:
2461                         break;
2462
2463                         case 7:
2464                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2465                         break;
2466
2467                         case 8:
2468                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2469                         break;
2470
2471                         case 9:
2472                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2473                         break;
2474
2475                         default:
2476                         break;
2477
2478                 }
2479         }
2480         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2481         return NDR_ERR_SUCCESS;
2482 }
2483
2484 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2485 {
2486         int level;
2487         level = ndr_print_get_switch_value(ndr, r);
2488         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2489         switch (level) {
2490                 case 0:
2491                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2492                 break;
2493
2494                 case 1:
2495                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2496                 break;
2497
2498                 case 2:
2499                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2500                 break;
2501
2502                 case 3:
2503                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2504                 break;
2505
2506                 case 4:
2507                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2508                 break;
2509
2510                 case 5:
2511                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2512                 break;
2513
2514                 case 6:
2515                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2516                 break;
2517
2518                 case 7:
2519                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2520                 break;
2521
2522                 case 8:
2523                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2524                 break;
2525
2526                 case 9:
2527                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2528                 break;
2529
2530                 default:
2531                 break;
2532
2533         }
2534 }
2535
2536 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2537 {
2538         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2539 }
2540
2541 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2542 {
2543         if (ndr_flags & NDR_SCALARS) {
2544                 NDR_CHECK(ndr_push_align(ndr, 4));
2545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2547         }
2548         if (ndr_flags & NDR_BUFFERS) {
2549                 if (r->devmode) {
2550                         {
2551                                 struct ndr_push *_ndr_devmode;
2552                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2553                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2554                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2555                         }
2556                 }
2557         }
2558         return NDR_ERR_SUCCESS;
2559 }
2560
2561 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2562 {
2563         uint32_t _ptr_devmode;
2564         TALLOC_CTX *_mem_save_devmode_0;
2565         if (ndr_flags & NDR_SCALARS) {
2566                 NDR_CHECK(ndr_pull_align(ndr, 4));
2567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2569                 if (_ptr_devmode) {
2570                         NDR_PULL_ALLOC(ndr, r->devmode);
2571                 } else {
2572                         r->devmode = NULL;
2573                 }
2574         }
2575         if (ndr_flags & NDR_BUFFERS) {
2576                 if (r->devmode) {
2577                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2578                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2579                         {
2580                                 struct ndr_pull *_ndr_devmode;
2581                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2582                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2583                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2584                         }
2585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2586                 }
2587         }
2588         return NDR_ERR_SUCCESS;
2589 }
2590
2591 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2592 {
2593         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2594         ndr->depth++;
2595         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);
2596         ndr_print_ptr(ndr, "devmode", r->devmode);
2597         ndr->depth++;
2598         if (r->devmode) {
2599                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2600         }
2601         ndr->depth--;
2602         ndr->depth--;
2603 }
2604
2605 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2606 {
2607         if (ndr_flags & NDR_SCALARS) {
2608                 NDR_CHECK(ndr_push_align(ndr, 4));
2609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2610                 {
2611                         uint32_t _flags_save_string = ndr->flags;
2612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2613                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2614                         ndr->flags = _flags_save_string;
2615                 }
2616                 {
2617                         uint32_t _flags_save_string = ndr->flags;
2618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2619                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2620                         ndr->flags = _flags_save_string;
2621                 }
2622                 {
2623                         uint32_t _flags_save_string = ndr->flags;
2624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2625                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2626                         ndr->flags = _flags_save_string;
2627                 }
2628                 {
2629                         uint32_t _flags_save_string = ndr->flags;
2630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2631                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2632                         ndr->flags = _flags_save_string;
2633                 }
2634                 {
2635                         uint32_t _flags_save_string = ndr->flags;
2636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2638                         ndr->flags = _flags_save_string;
2639                 }
2640                 {
2641                         uint32_t _flags_save_string = ndr->flags;
2642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2643                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2644                         ndr->flags = _flags_save_string;
2645                 }
2646                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2651                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2652         }
2653         if (ndr_flags & NDR_BUFFERS) {
2654                 {
2655                         uint32_t _flags_save_string = ndr->flags;
2656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2657                         if (r->printer_name) {
2658                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2659                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2660                         }
2661                         ndr->flags = _flags_save_string;
2662                 }
2663                 {
2664                         uint32_t _flags_save_string = ndr->flags;
2665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2666                         if (r->server_name) {
2667                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2668                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2669                         }
2670                         ndr->flags = _flags_save_string;
2671                 }
2672                 {
2673                         uint32_t _flags_save_string = ndr->flags;
2674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2675                         if (r->user_name) {
2676                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2677                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2678                         }
2679                         ndr->flags = _flags_save_string;
2680                 }
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         if (r->document_name) {
2685                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2686                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2687                         }
2688                         ndr->flags = _flags_save_string;
2689                 }
2690                 {
2691                         uint32_t _flags_save_string = ndr->flags;
2692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2693                         if (r->data_type) {
2694                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2695                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2696                         }
2697                         ndr->flags = _flags_save_string;
2698                 }
2699                 {
2700                         uint32_t _flags_save_string = ndr->flags;
2701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2702                         if (r->text_status) {
2703                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2704                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2705                         }
2706                         ndr->flags = _flags_save_string;
2707                 }
2708         }
2709         return NDR_ERR_SUCCESS;
2710 }
2711
2712 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2713 {
2714         uint32_t _ptr_printer_name;
2715         TALLOC_CTX *_mem_save_printer_name_0;
2716         uint32_t _ptr_server_name;
2717         TALLOC_CTX *_mem_save_server_name_0;
2718         uint32_t _ptr_user_name;
2719         TALLOC_CTX *_mem_save_user_name_0;
2720         uint32_t _ptr_document_name;
2721         TALLOC_CTX *_mem_save_document_name_0;
2722         uint32_t _ptr_data_type;
2723         TALLOC_CTX *_mem_save_data_type_0;
2724         uint32_t _ptr_text_status;
2725         TALLOC_CTX *_mem_save_text_status_0;
2726         if (ndr_flags & NDR_SCALARS) {
2727                 NDR_CHECK(ndr_pull_align(ndr, 4));
2728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
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_printer_name));
2733                         if (_ptr_printer_name) {
2734                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2736                         } else {
2737                                 r->printer_name = 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_server_name));
2745                         if (_ptr_server_name) {
2746                                 NDR_PULL_ALLOC(ndr, r->server_name);
2747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2748                         } else {
2749                                 r->server_name = NULL;
2750                         }
2751                         ndr->flags = _flags_save_string;
2752                 }
2753                 {
2754                         uint32_t _flags_save_string = ndr->flags;
2755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2757                         if (_ptr_user_name) {
2758                                 NDR_PULL_ALLOC(ndr, r->user_name);
2759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2760                         } else {
2761                                 r->user_name = NULL;
2762                         }
2763                         ndr->flags = _flags_save_string;
2764                 }
2765                 {
2766                         uint32_t _flags_save_string = ndr->flags;
2767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2768                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2769                         if (_ptr_document_name) {
2770                                 NDR_PULL_ALLOC(ndr, r->document_name);
2771                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2772                         } else {
2773                                 r->document_name = NULL;
2774                         }
2775                         ndr->flags = _flags_save_string;
2776                 }
2777                 {
2778                         uint32_t _flags_save_string = ndr->flags;
2779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2780                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2781                         if (_ptr_data_type) {
2782                                 NDR_PULL_ALLOC(ndr, r->data_type);
2783                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2784                         } else {
2785                                 r->data_type = NULL;
2786                         }
2787                         ndr->flags = _flags_save_string;
2788                 }
2789                 {
2790                         uint32_t _flags_save_string = ndr->flags;
2791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2792                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2793                         if (_ptr_text_status) {
2794                                 NDR_PULL_ALLOC(ndr, r->text_status);
2795                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2796                         } else {
2797                                 r->text_status = NULL;
2798                         }
2799                         ndr->flags = _flags_save_string;
2800                 }
2801                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2803                 if (r->priority > 99) {
2804                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2805                 }
2806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2809                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2810         }
2811         if (ndr_flags & NDR_BUFFERS) {
2812                 {
2813                         uint32_t _flags_save_string = ndr->flags;
2814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2815                         if (r->printer_name) {
2816                                 uint32_t _relative_save_offset;
2817                                 _relative_save_offset = ndr->offset;
2818                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2819                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2820                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2821                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2822                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2823                                 ndr->offset = _relative_save_offset;
2824                         }
2825                         ndr->flags = _flags_save_string;
2826                 }
2827                 {
2828                         uint32_t _flags_save_string = ndr->flags;
2829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2830                         if (r->server_name) {
2831                                 uint32_t _relative_save_offset;
2832                                 _relative_save_offset = ndr->offset;
2833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2834                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2835                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2838                                 ndr->offset = _relative_save_offset;
2839                         }
2840                         ndr->flags = _flags_save_string;
2841                 }
2842                 {
2843                         uint32_t _flags_save_string = ndr->flags;
2844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2845                         if (r->user_name) {
2846                                 uint32_t _relative_save_offset;
2847                                 _relative_save_offset = ndr->offset;
2848                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2849                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2850                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2851                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2852                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2853                                 ndr->offset = _relative_save_offset;
2854                         }
2855                         ndr->flags = _flags_save_string;
2856                 }
2857                 {
2858                         uint32_t _flags_save_string = ndr->flags;
2859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2860                         if (r->document_name) {
2861                                 uint32_t _relative_save_offset;
2862                                 _relative_save_offset = ndr->offset;
2863                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2864                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2865                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2866                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2867                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2868                                 ndr->offset = _relative_save_offset;
2869                         }
2870                         ndr->flags = _flags_save_string;
2871                 }
2872                 {
2873                         uint32_t _flags_save_string = ndr->flags;
2874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2875                         if (r->data_type) {
2876                                 uint32_t _relative_save_offset;
2877                                 _relative_save_offset = ndr->offset;
2878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2879                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2880                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2883                                 ndr->offset = _relative_save_offset;
2884                         }
2885                         ndr->flags = _flags_save_string;
2886                 }
2887                 {
2888                         uint32_t _flags_save_string = ndr->flags;
2889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2890                         if (r->text_status) {
2891                                 uint32_t _relative_save_offset;
2892                                 _relative_save_offset = ndr->offset;
2893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2894                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2895                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2896                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2897                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2898                                 ndr->offset = _relative_save_offset;
2899                         }
2900                         ndr->flags = _flags_save_string;
2901                 }
2902         }
2903         return NDR_ERR_SUCCESS;
2904 }
2905
2906 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2907 {
2908         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2909         ndr->depth++;
2910         ndr_print_uint32(ndr, "job_id", r->job_id);
2911         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2912         ndr->depth++;
2913         if (r->printer_name) {
2914                 ndr_print_string(ndr, "printer_name", r->printer_name);
2915         }
2916         ndr->depth--;
2917         ndr_print_ptr(ndr, "server_name", r->server_name);
2918         ndr->depth++;
2919         if (r->server_name) {
2920                 ndr_print_string(ndr, "server_name", r->server_name);
2921         }
2922         ndr->depth--;
2923         ndr_print_ptr(ndr, "user_name", r->user_name);
2924         ndr->depth++;
2925         if (r->user_name) {
2926                 ndr_print_string(ndr, "user_name", r->user_name);
2927         }
2928         ndr->depth--;
2929         ndr_print_ptr(ndr, "document_name", r->document_name);
2930         ndr->depth++;
2931         if (r->document_name) {
2932                 ndr_print_string(ndr, "document_name", r->document_name);
2933         }
2934         ndr->depth--;
2935         ndr_print_ptr(ndr, "data_type", r->data_type);
2936         ndr->depth++;
2937         if (r->data_type) {
2938                 ndr_print_string(ndr, "data_type", r->data_type);
2939         }
2940         ndr->depth--;
2941         ndr_print_ptr(ndr, "text_status", r->text_status);
2942         ndr->depth++;
2943         if (r->text_status) {
2944                 ndr_print_string(ndr, "text_status", r->text_status);
2945         }
2946         ndr->depth--;
2947         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2948         ndr_print_uint32(ndr, "priority", r->priority);
2949         ndr_print_uint32(ndr, "position", r->position);
2950         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2951         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2952         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2953         ndr->depth--;
2954 }
2955
2956 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
2957 {
2958         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
2959 }
2960
2961 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2962 {
2963         if (ndr_flags & NDR_SCALARS) {
2964                 NDR_CHECK(ndr_push_align(ndr, 4));
2965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2966                 {
2967                         uint32_t _flags_save_string = ndr->flags;
2968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2970                         ndr->flags = _flags_save_string;
2971                 }
2972                 {
2973                         uint32_t _flags_save_string = ndr->flags;
2974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2976                         ndr->flags = _flags_save_string;
2977                 }
2978                 {
2979                         uint32_t _flags_save_string = ndr->flags;
2980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2982                         ndr->flags = _flags_save_string;
2983                 }
2984                 {
2985                         uint32_t _flags_save_string = ndr->flags;
2986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2988                         ndr->flags = _flags_save_string;
2989                 }
2990                 {
2991                         uint32_t _flags_save_string = ndr->flags;
2992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2994                         ndr->flags = _flags_save_string;
2995                 }
2996                 {
2997                         uint32_t _flags_save_string = ndr->flags;
2998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2999                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3000                         ndr->flags = _flags_save_string;
3001                 }
3002                 {
3003                         uint32_t _flags_save_string = ndr->flags;
3004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3005                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3006                         ndr->flags = _flags_save_string;
3007                 }
3008                 {
3009                         uint32_t _flags_save_string = ndr->flags;
3010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3012                         ndr->flags = _flags_save_string;
3013                 }
3014                 {
3015                         uint32_t _flags_save_string = ndr->flags;
3016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3017                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3018                         ndr->flags = _flags_save_string;
3019                 }
3020                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3021                 {
3022                         uint32_t _flags_save_string = ndr->flags;
3023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3024                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3025                         ndr->flags = _flags_save_string;
3026                 }
3027                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3028                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3035                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3038         }
3039         if (ndr_flags & NDR_BUFFERS) {
3040                 {
3041                         uint32_t _flags_save_string = ndr->flags;
3042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3043                         if (r->printer_name) {
3044                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3045                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3046                         }
3047                         ndr->flags = _flags_save_string;
3048                 }
3049                 {
3050                         uint32_t _flags_save_string = ndr->flags;
3051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3052                         if (r->server_name) {
3053                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3054                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3055                         }
3056                         ndr->flags = _flags_save_string;
3057                 }
3058                 {
3059                         uint32_t _flags_save_string = ndr->flags;
3060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3061                         if (r->user_name) {
3062                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3063                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3064                         }
3065                         ndr->flags = _flags_save_string;
3066                 }
3067                 {
3068                         uint32_t _flags_save_string = ndr->flags;
3069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3070                         if (r->document_name) {
3071                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3072                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3073                         }
3074                         ndr->flags = _flags_save_string;
3075                 }
3076                 {
3077                         uint32_t _flags_save_string = ndr->flags;
3078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3079                         if (r->notify_name) {
3080                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3081                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3082                         }
3083                         ndr->flags = _flags_save_string;
3084                 }
3085                 {
3086                         uint32_t _flags_save_string = ndr->flags;
3087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3088                         if (r->data_type) {
3089                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3090                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3091                         }
3092                         ndr->flags = _flags_save_string;
3093                 }
3094                 {
3095                         uint32_t _flags_save_string = ndr->flags;
3096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3097                         if (r->print_processor) {
3098                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3099                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3100                         }
3101                         ndr->flags = _flags_save_string;
3102                 }
3103                 {
3104                         uint32_t _flags_save_string = ndr->flags;
3105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3106                         if (r->parameters) {
3107                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3108                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3109                         }
3110                         ndr->flags = _flags_save_string;
3111                 }
3112                 {
3113                         uint32_t _flags_save_string = ndr->flags;
3114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3115                         if (r->driver_name) {
3116                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3117                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3118                         }
3119                         ndr->flags = _flags_save_string;
3120                 }
3121                 if (r->devmode) {
3122                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3123                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3124                 }
3125                 {
3126                         uint32_t _flags_save_string = ndr->flags;
3127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3128                         if (r->text_status) {
3129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3131                         }
3132                         ndr->flags = _flags_save_string;
3133                 }
3134                 if (r->secdesc) {
3135                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3136                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3137                 }
3138         }
3139         return NDR_ERR_SUCCESS;
3140 }
3141
3142 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3143 {
3144         uint32_t _ptr_printer_name;
3145         TALLOC_CTX *_mem_save_printer_name_0;
3146         uint32_t _ptr_server_name;
3147         TALLOC_CTX *_mem_save_server_name_0;
3148         uint32_t _ptr_user_name;
3149         TALLOC_CTX *_mem_save_user_name_0;
3150         uint32_t _ptr_document_name;
3151         TALLOC_CTX *_mem_save_document_name_0;
3152         uint32_t _ptr_notify_name;
3153         TALLOC_CTX *_mem_save_notify_name_0;
3154         uint32_t _ptr_data_type;
3155         TALLOC_CTX *_mem_save_data_type_0;
3156         uint32_t _ptr_print_processor;
3157         TALLOC_CTX *_mem_save_print_processor_0;
3158         uint32_t _ptr_parameters;
3159         TALLOC_CTX *_mem_save_parameters_0;
3160         uint32_t _ptr_driver_name;
3161         TALLOC_CTX *_mem_save_driver_name_0;
3162         uint32_t _ptr_devmode;
3163         TALLOC_CTX *_mem_save_devmode_0;
3164         uint32_t _ptr_text_status;
3165         TALLOC_CTX *_mem_save_text_status_0;
3166         uint32_t _ptr_secdesc;
3167         TALLOC_CTX *_mem_save_secdesc_0;
3168         if (ndr_flags & NDR_SCALARS) {
3169                 NDR_CHECK(ndr_pull_align(ndr, 4));
3170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3171                 {
3172                         uint32_t _flags_save_string = ndr->flags;
3173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3174                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3175                         if (_ptr_printer_name) {
3176                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3177                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3178                         } else {
3179                                 r->printer_name = NULL;
3180                         }
3181                         ndr->flags = _flags_save_string;
3182                 }
3183                 {
3184                         uint32_t _flags_save_string = ndr->flags;
3185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3186                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3187                         if (_ptr_server_name) {
3188                                 NDR_PULL_ALLOC(ndr, r->server_name);
3189                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3190                         } else {
3191                                 r->server_name = NULL;
3192                         }
3193                         ndr->flags = _flags_save_string;
3194                 }
3195                 {
3196                         uint32_t _flags_save_string = ndr->flags;
3197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3198                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3199                         if (_ptr_user_name) {
3200                                 NDR_PULL_ALLOC(ndr, r->user_name);
3201                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3202                         } else {
3203                                 r->user_name = NULL;
3204                         }
3205                         ndr->flags = _flags_save_string;
3206                 }
3207                 {
3208                         uint32_t _flags_save_string = ndr->flags;
3209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3210                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3211                         if (_ptr_document_name) {
3212                                 NDR_PULL_ALLOC(ndr, r->document_name);
3213                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3214                         } else {
3215                                 r->document_name = NULL;
3216                         }
3217                         ndr->flags = _flags_save_string;
3218                 }
3219                 {
3220                         uint32_t _flags_save_string = ndr->flags;
3221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3222                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3223                         if (_ptr_notify_name) {
3224                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3225                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3226                         } else {
3227                                 r->notify_name = NULL;
3228                         }
3229                         ndr->flags = _flags_save_string;
3230                 }
3231                 {
3232                         uint32_t _flags_save_string = ndr->flags;
3233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3234                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3235                         if (_ptr_data_type) {
3236                                 NDR_PULL_ALLOC(ndr, r->data_type);
3237                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3238                         } else {
3239                                 r->data_type = NULL;
3240                         }
3241                         ndr->flags = _flags_save_string;
3242                 }
3243                 {
3244                         uint32_t _flags_save_string = ndr->flags;
3245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3246                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3247                         if (_ptr_print_processor) {
3248                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3249                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3250                         } else {
3251                                 r->print_processor = NULL;
3252                         }
3253                         ndr->flags = _flags_save_string;
3254                 }
3255                 {
3256                         uint32_t _flags_save_string = ndr->flags;
3257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3258                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3259                         if (_ptr_parameters) {
3260                                 NDR_PULL_ALLOC(ndr, r->parameters);
3261                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3262                         } else {
3263                                 r->parameters = NULL;
3264                         }
3265                         ndr->flags = _flags_save_string;
3266                 }
3267                 {
3268                         uint32_t _flags_save_string = ndr->flags;
3269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3270                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3271                         if (_ptr_driver_name) {
3272                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3273                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3274                         } else {
3275                                 r->driver_name = NULL;
3276                         }
3277                         ndr->flags = _flags_save_string;
3278                 }
3279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3280                 if (_ptr_devmode) {
3281                         NDR_PULL_ALLOC(ndr, r->devmode);
3282                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3283                 } else {
3284                         r->devmode = NULL;
3285                 }
3286                 {
3287                         uint32_t _flags_save_string = ndr->flags;
3288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3289                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3290                         if (_ptr_text_status) {
3291                                 NDR_PULL_ALLOC(ndr, r->text_status);
3292                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3293                         } else {
3294                                 r->text_status = NULL;
3295                         }
3296                         ndr->flags = _flags_save_string;
3297                 }
3298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3299                 if (_ptr_secdesc) {
3300                         NDR_PULL_ALLOC(ndr, r->secdesc);
3301                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3302                 } else {
3303                         r->secdesc = NULL;
3304                 }
3305                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3307                 if (r->priority > 99) {
3308                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3309                 }
3310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3315                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3318         }
3319         if (ndr_flags & NDR_BUFFERS) {
3320                 {
3321                         uint32_t _flags_save_string = ndr->flags;
3322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3323                         if (r->printer_name) {
3324                                 uint32_t _relative_save_offset;
3325                                 _relative_save_offset = ndr->offset;
3326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3327                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3328                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3331                                 ndr->offset = _relative_save_offset;
3332                         }
3333                         ndr->flags = _flags_save_string;
3334                 }
3335                 {
3336                         uint32_t _flags_save_string = ndr->flags;
3337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3338                         if (r->server_name) {
3339                                 uint32_t _relative_save_offset;
3340                                 _relative_save_offset = ndr->offset;
3341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3342                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3343                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3344                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3346                                 ndr->offset = _relative_save_offset;
3347                         }
3348                         ndr->flags = _flags_save_string;
3349                 }
3350                 {
3351                         uint32_t _flags_save_string = ndr->flags;
3352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3353                         if (r->user_name) {
3354                                 uint32_t _relative_save_offset;
3355                                 _relative_save_offset = ndr->offset;
3356                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3357                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3358                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3359                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3360                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3361                                 ndr->offset = _relative_save_offset;
3362                         }
3363                         ndr->flags = _flags_save_string;
3364                 }
3365                 {
3366                         uint32_t _flags_save_string = ndr->flags;
3367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3368                         if (r->document_name) {
3369                                 uint32_t _relative_save_offset;
3370                                 _relative_save_offset = ndr->offset;
3371                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3372                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3373                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3374                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3375                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3376                                 ndr->offset = _relative_save_offset;
3377                         }
3378                         ndr->flags = _flags_save_string;
3379                 }
3380                 {
3381                         uint32_t _flags_save_string = ndr->flags;
3382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3383                         if (r->notify_name) {
3384                                 uint32_t _relative_save_offset;
3385                                 _relative_save_offset = ndr->offset;
3386                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3387                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3388                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3389                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3390                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3391                                 ndr->offset = _relative_save_offset;
3392                         }
3393                         ndr->flags = _flags_save_string;
3394                 }
3395                 {
3396                         uint32_t _flags_save_string = ndr->flags;
3397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3398                         if (r->data_type) {
3399                                 uint32_t _relative_save_offset;
3400                                 _relative_save_offset = ndr->offset;
3401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3402                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3403                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3404                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3406                                 ndr->offset = _relative_save_offset;
3407                         }
3408                         ndr->flags = _flags_save_string;
3409                 }
3410                 {
3411                         uint32_t _flags_save_string = ndr->flags;
3412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3413                         if (r->print_processor) {
3414                                 uint32_t _relative_save_offset;
3415                                 _relative_save_offset = ndr->offset;
3416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3417                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3418                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3421                                 ndr->offset = _relative_save_offset;
3422                         }
3423                         ndr->flags = _flags_save_string;
3424                 }
3425                 {
3426                         uint32_t _flags_save_string = ndr->flags;
3427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3428                         if (r->parameters) {
3429                                 uint32_t _relative_save_offset;
3430                                 _relative_save_offset = ndr->offset;
3431                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3432                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3433                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3434                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3435                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3436                                 ndr->offset = _relative_save_offset;
3437                         }
3438                         ndr->flags = _flags_save_string;
3439                 }
3440                 {
3441                         uint32_t _flags_save_string = ndr->flags;
3442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3443                         if (r->driver_name) {
3444                                 uint32_t _relative_save_offset;
3445                                 _relative_save_offset = ndr->offset;
3446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3447                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3448                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3451                                 ndr->offset = _relative_save_offset;
3452                         }
3453                         ndr->flags = _flags_save_string;
3454                 }
3455                 if (r->devmode) {
3456                         uint32_t _relative_save_offset;
3457                         _relative_save_offset = ndr->offset;
3458                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3459                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3460                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3461                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3463                         ndr->offset = _relative_save_offset;
3464                 }
3465                 {
3466                         uint32_t _flags_save_string = ndr->flags;
3467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3468                         if (r->text_status) {
3469                                 uint32_t _relative_save_offset;
3470                                 _relative_save_offset = ndr->offset;
3471                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3472                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3473                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3474                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3475                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3476                                 ndr->offset = _relative_save_offset;
3477                         }
3478                         ndr->flags = _flags_save_string;
3479                 }
3480                 if (r->secdesc) {
3481                         uint32_t _relative_save_offset;
3482                         _relative_save_offset = ndr->offset;
3483                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3484                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3485                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3486                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3488                         ndr->offset = _relative_save_offset;
3489                 }
3490         }
3491         return NDR_ERR_SUCCESS;
3492 }
3493
3494 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3495 {
3496         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3497         ndr->depth++;
3498         ndr_print_uint32(ndr, "job_id", r->job_id);
3499         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3500         ndr->depth++;
3501         if (r->printer_name) {
3502                 ndr_print_string(ndr, "printer_name", r->printer_name);
3503         }
3504         ndr->depth--;
3505         ndr_print_ptr(ndr, "server_name", r->server_name);
3506         ndr->depth++;
3507         if (r->server_name) {
3508                 ndr_print_string(ndr, "server_name", r->server_name);
3509         }
3510         ndr->depth--;
3511         ndr_print_ptr(ndr, "user_name", r->user_name);
3512         ndr->depth++;
3513         if (r->user_name) {
3514                 ndr_print_string(ndr, "user_name", r->user_name);
3515         }
3516         ndr->depth--;
3517         ndr_print_ptr(ndr, "document_name", r->document_name);
3518         ndr->depth++;
3519         if (r->document_name) {
3520                 ndr_print_string(ndr, "document_name", r->document_name);
3521         }
3522         ndr->depth--;
3523         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3524         ndr->depth++;
3525         if (r->notify_name) {
3526                 ndr_print_string(ndr, "notify_name", r->notify_name);
3527         }
3528         ndr->depth--;
3529         ndr_print_ptr(ndr, "data_type", r->data_type);
3530         ndr->depth++;
3531         if (r->data_type) {
3532                 ndr_print_string(ndr, "data_type", r->data_type);
3533         }
3534         ndr->depth--;
3535         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3536         ndr->depth++;
3537         if (r->print_processor) {
3538                 ndr_print_string(ndr, "print_processor", r->print_processor);
3539         }
3540         ndr->depth--;
3541         ndr_print_ptr(ndr, "parameters", r->parameters);
3542         ndr->depth++;
3543         if (r->parameters) {
3544                 ndr_print_string(ndr, "parameters", r->parameters);
3545         }
3546         ndr->depth--;
3547         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3548         ndr->depth++;
3549         if (r->driver_name) {
3550                 ndr_print_string(ndr, "driver_name", r->driver_name);
3551         }
3552         ndr->depth--;
3553         ndr_print_ptr(ndr, "devmode", r->devmode);
3554         ndr->depth++;
3555         if (r->devmode) {
3556                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3557         }
3558         ndr->depth--;
3559         ndr_print_ptr(ndr, "text_status", r->text_status);
3560         ndr->depth++;
3561         if (r->text_status) {
3562                 ndr_print_string(ndr, "text_status", r->text_status);
3563         }
3564         ndr->depth--;
3565         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3566         ndr->depth++;
3567         if (r->secdesc) {
3568                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3569         }
3570         ndr->depth--;
3571         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3572         ndr_print_uint32(ndr, "priority", r->priority);
3573         ndr_print_uint32(ndr, "position", r->position);
3574         ndr_print_uint32(ndr, "start_time", r->start_time);
3575         ndr_print_uint32(ndr, "until_time", r->until_time);
3576         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3577         ndr_print_uint32(ndr, "size", r->size);
3578         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3579         ndr_print_uint32(ndr, "time", r->time);
3580         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3581         ndr->depth--;
3582 }
3583
3584 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
3585 {
3586         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
3587 }
3588
3589 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3590 {
3591         if (ndr_flags & NDR_SCALARS) {
3592                 NDR_CHECK(ndr_push_align(ndr, 4));
3593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3596         }
3597         if (ndr_flags & NDR_BUFFERS) {
3598         }
3599         return NDR_ERR_SUCCESS;
3600 }
3601
3602 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3603 {
3604         if (ndr_flags & NDR_SCALARS) {
3605                 NDR_CHECK(ndr_pull_align(ndr, 4));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3609         }
3610         if (ndr_flags & NDR_BUFFERS) {
3611         }
3612         return NDR_ERR_SUCCESS;
3613 }
3614
3615 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3616 {
3617         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3618         ndr->depth++;
3619         ndr_print_uint32(ndr, "job_id", r->job_id);
3620         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3621         ndr_print_uint32(ndr, "reserved", r->reserved);
3622         ndr->depth--;
3623 }
3624
3625 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
3626 {
3627         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
3628 }
3629
3630 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3631 {
3632         if (ndr_flags & NDR_SCALARS) {
3633                 NDR_CHECK(ndr_push_align(ndr, 4));
3634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3635                 {
3636                         uint32_t _flags_save_string = ndr->flags;
3637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3638                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3639                         ndr->flags = _flags_save_string;
3640                 }
3641                 {
3642                         uint32_t _flags_save_string = ndr->flags;
3643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3644                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3645                         ndr->flags = _flags_save_string;
3646                 }
3647                 {
3648                         uint32_t _flags_save_string = ndr->flags;
3649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3650                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3651                         ndr->flags = _flags_save_string;
3652                 }
3653                 {
3654                         uint32_t _flags_save_string = ndr->flags;
3655                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3656                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3657                         ndr->flags = _flags_save_string;
3658                 }
3659                 {
3660                         uint32_t _flags_save_string = ndr->flags;
3661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3662                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3669                         ndr->flags = _flags_save_string;
3670                 }
3671                 {
3672                         uint32_t _flags_save_string = ndr->flags;
3673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3674                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3675                         ndr->flags = _flags_save_string;
3676                 }
3677                 {
3678                         uint32_t _flags_save_string = ndr->flags;
3679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3680                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3687                         ndr->flags = _flags_save_string;
3688                 }
3689                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3690                 {
3691                         uint32_t _flags_save_string = ndr->flags;
3692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3693                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3694                         ndr->flags = _flags_save_string;
3695                 }
3696                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3697                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3704                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3708         }
3709         if (ndr_flags & NDR_BUFFERS) {
3710                 {
3711                         uint32_t _flags_save_string = ndr->flags;
3712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3713                         if (r->printer_name) {
3714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3716                         }
3717                         ndr->flags = _flags_save_string;
3718                 }
3719                 {
3720                         uint32_t _flags_save_string = ndr->flags;
3721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3722                         if (r->server_name) {
3723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3725                         }
3726                         ndr->flags = _flags_save_string;
3727                 }
3728                 {
3729                         uint32_t _flags_save_string = ndr->flags;
3730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3731                         if (r->user_name) {
3732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3734                         }
3735                         ndr->flags = _flags_save_string;
3736                 }
3737                 {
3738                         uint32_t _flags_save_string = ndr->flags;
3739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3740                         if (r->document_name) {
3741                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3742                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3743                         }
3744                         ndr->flags = _flags_save_string;
3745                 }
3746                 {
3747                         uint32_t _flags_save_string = ndr->flags;
3748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3749                         if (r->notify_name) {
3750                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3751                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3752                         }
3753                         ndr->flags = _flags_save_string;
3754                 }
3755                 {
3756                         uint32_t _flags_save_string = ndr->flags;
3757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3758                         if (r->data_type) {
3759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3760                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3761                         }
3762                         ndr->flags = _flags_save_string;
3763                 }
3764                 {
3765                         uint32_t _flags_save_string = ndr->flags;
3766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3767                         if (r->print_processor) {
3768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3770                         }
3771                         ndr->flags = _flags_save_string;
3772                 }
3773                 {
3774                         uint32_t _flags_save_string = ndr->flags;
3775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3776                         if (r->parameters) {
3777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3779                         }
3780                         ndr->flags = _flags_save_string;
3781                 }
3782                 {
3783                         uint32_t _flags_save_string = ndr->flags;
3784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3785                         if (r->driver_name) {
3786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3788                         }
3789                         ndr->flags = _flags_save_string;
3790                 }
3791                 if (r->devmode) {
3792                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3793                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3794                 }
3795                 {
3796                         uint32_t _flags_save_string = ndr->flags;
3797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3798                         if (r->text_status) {
3799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3801                         }
3802                         ndr->flags = _flags_save_string;
3803                 }
3804                 if (r->secdesc) {
3805                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3806                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3807                 }
3808         }
3809         return NDR_ERR_SUCCESS;
3810 }
3811
3812 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3813 {
3814         uint32_t _ptr_printer_name;
3815         TALLOC_CTX *_mem_save_printer_name_0;
3816         uint32_t _ptr_server_name;
3817         TALLOC_CTX *_mem_save_server_name_0;
3818         uint32_t _ptr_user_name;
3819         TALLOC_CTX *_mem_save_user_name_0;
3820         uint32_t _ptr_document_name;
3821         TALLOC_CTX *_mem_save_document_name_0;
3822         uint32_t _ptr_notify_name;
3823         TALLOC_CTX *_mem_save_notify_name_0;
3824         uint32_t _ptr_data_type;
3825         TALLOC_CTX *_mem_save_data_type_0;
3826         uint32_t _ptr_print_processor;
3827         TALLOC_CTX *_mem_save_print_processor_0;
3828         uint32_t _ptr_parameters;
3829         TALLOC_CTX *_mem_save_parameters_0;
3830         uint32_t _ptr_driver_name;
3831         TALLOC_CTX *_mem_save_driver_name_0;
3832         uint32_t _ptr_devmode;
3833         TALLOC_CTX *_mem_save_devmode_0;
3834         uint32_t _ptr_text_status;
3835         TALLOC_CTX *_mem_save_text_status_0;
3836         uint32_t _ptr_secdesc;
3837         TALLOC_CTX *_mem_save_secdesc_0;
3838         if (ndr_flags & NDR_SCALARS) {
3839                 NDR_CHECK(ndr_pull_align(ndr, 4));
3840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3841                 {
3842                         uint32_t _flags_save_string = ndr->flags;
3843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3844                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3845                         if (_ptr_printer_name) {
3846                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3847                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3848                         } else {
3849                                 r->printer_name = NULL;
3850                         }
3851                         ndr->flags = _flags_save_string;
3852                 }
3853                 {
3854                         uint32_t _flags_save_string = ndr->flags;
3855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3856                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3857                         if (_ptr_server_name) {
3858                                 NDR_PULL_ALLOC(ndr, r->server_name);
3859                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3860                         } else {
3861                                 r->server_name = NULL;
3862                         }
3863                         ndr->flags = _flags_save_string;
3864                 }
3865                 {
3866                         uint32_t _flags_save_string = ndr->flags;
3867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3868                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3869                         if (_ptr_user_name) {
3870                                 NDR_PULL_ALLOC(ndr, r->user_name);
3871                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3872                         } else {
3873                                 r->user_name = NULL;
3874                         }
3875                         ndr->flags = _flags_save_string;
3876                 }
3877                 {
3878                         uint32_t _flags_save_string = ndr->flags;
3879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3880                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3881                         if (_ptr_document_name) {
3882                                 NDR_PULL_ALLOC(ndr, r->document_name);
3883                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3884                         } else {
3885                                 r->document_name = NULL;
3886                         }
3887                         ndr->flags = _flags_save_string;
3888                 }
3889                 {
3890                         uint32_t _flags_save_string = ndr->flags;
3891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3892                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3893                         if (_ptr_notify_name) {
3894                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3895                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3896                         } else {
3897                                 r->notify_name = NULL;
3898                         }
3899                         ndr->flags = _flags_save_string;
3900                 }
3901                 {
3902                         uint32_t _flags_save_string = ndr->flags;
3903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3905                         if (_ptr_data_type) {
3906                                 NDR_PULL_ALLOC(ndr, r->data_type);
3907                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3908                         } else {
3909                                 r->data_type = NULL;
3910                         }
3911                         ndr->flags = _flags_save_string;
3912                 }
3913                 {
3914                         uint32_t _flags_save_string = ndr->flags;
3915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3916                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3917                         if (_ptr_print_processor) {
3918                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3919                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3920                         } else {
3921                                 r->print_processor = NULL;
3922                         }
3923                         ndr->flags = _flags_save_string;
3924                 }
3925                 {
3926                         uint32_t _flags_save_string = ndr->flags;
3927                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3928                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3929                         if (_ptr_parameters) {
3930                                 NDR_PULL_ALLOC(ndr, r->parameters);
3931                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3932                         } else {
3933                                 r->parameters = NULL;
3934                         }
3935                         ndr->flags = _flags_save_string;
3936                 }
3937                 {
3938                         uint32_t _flags_save_string = ndr->flags;
3939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3940                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3941                         if (_ptr_driver_name) {
3942                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3943                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3944                         } else {
3945                                 r->driver_name = NULL;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3950                 if (_ptr_devmode) {
3951                         NDR_PULL_ALLOC(ndr, r->devmode);
3952                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3953                 } else {
3954                         r->devmode = NULL;
3955                 }
3956                 {
3957                         uint32_t _flags_save_string = ndr->flags;
3958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3959                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3960                         if (_ptr_text_status) {
3961                                 NDR_PULL_ALLOC(ndr, r->text_status);
3962                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3963                         } else {
3964                                 r->text_status = NULL;
3965                         }
3966                         ndr->flags = _flags_save_string;
3967                 }
3968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3969                 if (_ptr_secdesc) {
3970                         NDR_PULL_ALLOC(ndr, r->secdesc);
3971                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3972                 } else {
3973                         r->secdesc = NULL;
3974                 }
3975                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3977                 if (r->priority > 99) {
3978                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3979                 }
3980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3985                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3989         }
3990         if (ndr_flags & NDR_BUFFERS) {
3991                 {
3992                         uint32_t _flags_save_string = ndr->flags;
3993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3994                         if (r->printer_name) {
3995                                 uint32_t _relative_save_offset;
3996                                 _relative_save_offset = ndr->offset;
3997                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3998                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3999                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4000                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4001                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4002                                 ndr->offset = _relative_save_offset;
4003                         }
4004                         ndr->flags = _flags_save_string;
4005                 }
4006                 {
4007                         uint32_t _flags_save_string = ndr->flags;
4008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4009                         if (r->server_name) {
4010                                 uint32_t _relative_save_offset;
4011                                 _relative_save_offset = ndr->offset;
4012                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4013                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4014                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4015                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4016                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4017                                 ndr->offset = _relative_save_offset;
4018                         }
4019                         ndr->flags = _flags_save_string;
4020                 }
4021                 {
4022                         uint32_t _flags_save_string = ndr->flags;
4023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4024                         if (r->user_name) {
4025                                 uint32_t _relative_save_offset;
4026                                 _relative_save_offset = ndr->offset;
4027                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4028                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4029                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4030                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4031                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4032                                 ndr->offset = _relative_save_offset;
4033                         }
4034                         ndr->flags = _flags_save_string;
4035                 }
4036                 {
4037                         uint32_t _flags_save_string = ndr->flags;
4038                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4039                         if (r->document_name) {
4040                                 uint32_t _relative_save_offset;
4041                                 _relative_save_offset = ndr->offset;
4042                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4043                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4044                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4045                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4046                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4047                                 ndr->offset = _relative_save_offset;
4048                         }
4049                         ndr->flags = _flags_save_string;
4050                 }
4051                 {
4052                         uint32_t _flags_save_string = ndr->flags;
4053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4054                         if (r->notify_name) {
4055                                 uint32_t _relative_save_offset;
4056                                 _relative_save_offset = ndr->offset;
4057                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4058                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4059                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4060                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4061                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4062                                 ndr->offset = _relative_save_offset;
4063                         }
4064                         ndr->flags = _flags_save_string;
4065                 }
4066                 {
4067                         uint32_t _flags_save_string = ndr->flags;
4068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4069                         if (r->data_type) {
4070                                 uint32_t _relative_save_offset;
4071                                 _relative_save_offset = ndr->offset;
4072                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4073                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4074                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4075                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4076                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4077                                 ndr->offset = _relative_save_offset;
4078                         }
4079                         ndr->flags = _flags_save_string;
4080                 }
4081                 {
4082                         uint32_t _flags_save_string = ndr->flags;
4083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4084                         if (r->print_processor) {
4085                                 uint32_t _relative_save_offset;
4086                                 _relative_save_offset = ndr->offset;
4087                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4088                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4089                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4090                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4091                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4092                                 ndr->offset = _relative_save_offset;
4093                         }
4094                         ndr->flags = _flags_save_string;
4095                 }
4096                 {
4097                         uint32_t _flags_save_string = ndr->flags;
4098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4099                         if (r->parameters) {
4100                                 uint32_t _relative_save_offset;
4101                                 _relative_save_offset = ndr->offset;
4102                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4103                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4104                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4105                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4106                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4107                                 ndr->offset = _relative_save_offset;
4108                         }
4109                         ndr->flags = _flags_save_string;
4110                 }
4111                 {
4112                         uint32_t _flags_save_string = ndr->flags;
4113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4114                         if (r->driver_name) {
4115                                 uint32_t _relative_save_offset;
4116                                 _relative_save_offset = ndr->offset;
4117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4118                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4119                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4120                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4122                                 ndr->offset = _relative_save_offset;
4123                         }
4124                         ndr->flags = _flags_save_string;
4125                 }
4126                 if (r->devmode) {
4127                         uint32_t _relative_save_offset;
4128                         _relative_save_offset = ndr->offset;
4129                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4130                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4131                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4132                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4134                         ndr->offset = _relative_save_offset;
4135                 }
4136                 {
4137                         uint32_t _flags_save_string = ndr->flags;
4138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4139                         if (r->text_status) {
4140                                 uint32_t _relative_save_offset;
4141                                 _relative_save_offset = ndr->offset;
4142                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4143                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4144                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4145                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4146                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4147                                 ndr->offset = _relative_save_offset;
4148                         }
4149                         ndr->flags = _flags_save_string;
4150                 }
4151                 if (r->secdesc) {
4152                         uint32_t _relative_save_offset;
4153                         _relative_save_offset = ndr->offset;
4154                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4155                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4156                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4157                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4159                         ndr->offset = _relative_save_offset;
4160                 }
4161         }
4162         return NDR_ERR_SUCCESS;
4163 }
4164
4165 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4166 {
4167         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4168         ndr->depth++;
4169         ndr_print_uint32(ndr, "job_id", r->job_id);
4170         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4171         ndr->depth++;
4172         if (r->printer_name) {
4173                 ndr_print_string(ndr, "printer_name", r->printer_name);
4174         }
4175         ndr->depth--;
4176         ndr_print_ptr(ndr, "server_name", r->server_name);
4177         ndr->depth++;
4178         if (r->server_name) {
4179                 ndr_print_string(ndr, "server_name", r->server_name);
4180         }
4181         ndr->depth--;
4182         ndr_print_ptr(ndr, "user_name", r->user_name);
4183         ndr->depth++;
4184         if (r->user_name) {
4185                 ndr_print_string(ndr, "user_name", r->user_name);
4186         }
4187         ndr->depth--;
4188         ndr_print_ptr(ndr, "document_name", r->document_name);
4189         ndr->depth++;
4190         if (r->document_name) {
4191                 ndr_print_string(ndr, "document_name", r->document_name);
4192         }
4193         ndr->depth--;
4194         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4195         ndr->depth++;
4196         if (r->notify_name) {
4197                 ndr_print_string(ndr, "notify_name", r->notify_name);
4198         }
4199         ndr->depth--;
4200         ndr_print_ptr(ndr, "data_type", r->data_type);
4201         ndr->depth++;
4202         if (r->data_type) {
4203                 ndr_print_string(ndr, "data_type", r->data_type);
4204         }
4205         ndr->depth--;
4206         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4207         ndr->depth++;
4208         if (r->print_processor) {
4209                 ndr_print_string(ndr, "print_processor", r->print_processor);
4210         }
4211         ndr->depth--;
4212         ndr_print_ptr(ndr, "parameters", r->parameters);
4213         ndr->depth++;
4214         if (r->parameters) {
4215                 ndr_print_string(ndr, "parameters", r->parameters);
4216         }
4217         ndr->depth--;
4218         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4219         ndr->depth++;
4220         if (r->driver_name) {
4221                 ndr_print_string(ndr, "driver_name", r->driver_name);
4222         }
4223         ndr->depth--;
4224         ndr_print_ptr(ndr, "devmode", r->devmode);
4225         ndr->depth++;
4226         if (r->devmode) {
4227                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4228         }
4229         ndr->depth--;
4230         ndr_print_ptr(ndr, "text_status", r->text_status);
4231         ndr->depth++;
4232         if (r->text_status) {
4233                 ndr_print_string(ndr, "text_status", r->text_status);
4234         }
4235         ndr->depth--;
4236         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4237         ndr->depth++;
4238         if (r->secdesc) {
4239                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4240         }
4241         ndr->depth--;
4242         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4243         ndr_print_uint32(ndr, "priority", r->priority);
4244         ndr_print_uint32(ndr, "position", r->position);
4245         ndr_print_uint32(ndr, "start_time", r->start_time);
4246         ndr_print_uint32(ndr, "until_time", r->until_time);
4247         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4248         ndr_print_uint32(ndr, "size", r->size);
4249         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4250         ndr_print_uint32(ndr, "time", r->time);
4251         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4252         ndr_print_uint32(ndr, "size_high", r->size_high);
4253         ndr->depth--;
4254 }
4255
4256 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4257 {
4258         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4259 }
4260
4261 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4262 {
4263         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4264         if (ndr_flags & NDR_SCALARS) {
4265                 int level = ndr_push_get_switch_value(ndr, r);
4266                 switch (level) {
4267                         case 1: {
4268                                 NDR_CHECK(ndr_push_align(ndr, 4));
4269                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4270                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4271                         break; }
4272
4273                         case 2: {
4274                                 NDR_CHECK(ndr_push_align(ndr, 4));
4275                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4276                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4277                         break; }
4278
4279                         case 3: {
4280                                 NDR_CHECK(ndr_push_align(ndr, 4));
4281                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4282                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4283                         break; }
4284
4285                         case 4: {
4286                                 NDR_CHECK(ndr_push_align(ndr, 4));
4287                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4288                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4289                         break; }
4290
4291                         default: {
4292                         break; }
4293
4294                 }
4295         }
4296         if (ndr_flags & NDR_BUFFERS) {
4297                 int level = ndr_push_get_switch_value(ndr, r);
4298                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4299                 switch (level) {
4300                         case 1:
4301                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4302                         break;
4303
4304                         case 2:
4305                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4306                         break;
4307
4308                         case 3:
4309                         break;
4310
4311                         case 4:
4312                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4313                         break;
4314
4315                         default:
4316                         break;
4317
4318                 }
4319         }
4320         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4321         return NDR_ERR_SUCCESS;
4322 }
4323
4324 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4325 {
4326         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4327         int level;
4328         level = ndr_pull_get_switch_value(ndr, r);
4329         if (ndr_flags & NDR_SCALARS) {
4330                 switch (level) {
4331                         case 1: {
4332                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4333                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4334                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4335                         break; }
4336
4337                         case 2: {
4338                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4339                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4340                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4341                         break; }
4342
4343                         case 3: {
4344                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4345                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4346                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4347                         break; }
4348
4349                         case 4: {
4350                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4351                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4352                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4353                         break; }
4354
4355                         default: {
4356                         break; }
4357
4358                 }
4359         }
4360         if (ndr_flags & NDR_BUFFERS) {
4361                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4362                 switch (level) {
4363                         case 1:
4364                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4365                         break;
4366
4367                         case 2:
4368                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4369                         break;
4370
4371                         case 3:
4372                         break;
4373
4374                         case 4:
4375                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4376                         break;
4377
4378                         default:
4379                         break;
4380
4381                 }
4382         }
4383         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4384         return NDR_ERR_SUCCESS;
4385 }
4386
4387 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4388 {
4389         int level;
4390         level = ndr_print_get_switch_value(ndr, r);
4391         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4392         switch (level) {
4393                 case 1:
4394                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4395                 break;
4396
4397                 case 2:
4398                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4399                 break;
4400
4401                 case 3:
4402                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4403                 break;
4404
4405                 case 4:
4406                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4407                 break;
4408
4409                 default:
4410                 break;
4411
4412         }
4413 }
4414
4415 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4416 {
4417         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4418 }
4419
4420 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4421 {
4422         if (ndr_flags & NDR_SCALARS) {
4423                 NDR_CHECK(ndr_push_align(ndr, 4));
4424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4427                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4431                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4436                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4437         }
4438         if (ndr_flags & NDR_BUFFERS) {
4439                 if (r->printer_name) {
4440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4444                 }
4445                 if (r->server_name) {
4446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4449                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4450                 }
4451                 if (r->user_name) {
4452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4456                 }
4457                 if (r->document_name) {
4458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4462                 }
4463                 if (r->data_type) {
4464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4467                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4468                 }
4469                 if (r->text_status) {
4470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4473                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4474                 }
4475         }
4476         return NDR_ERR_SUCCESS;
4477 }
4478
4479 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4480 {
4481         uint32_t _ptr_printer_name;
4482         TALLOC_CTX *_mem_save_printer_name_0;
4483         uint32_t _ptr_server_name;
4484         TALLOC_CTX *_mem_save_server_name_0;
4485         uint32_t _ptr_user_name;
4486         TALLOC_CTX *_mem_save_user_name_0;
4487         uint32_t _ptr_document_name;
4488         TALLOC_CTX *_mem_save_document_name_0;
4489         uint32_t _ptr_data_type;
4490         TALLOC_CTX *_mem_save_data_type_0;
4491         uint32_t _ptr_text_status;
4492         TALLOC_CTX *_mem_save_text_status_0;
4493         if (ndr_flags & NDR_SCALARS) {
4494                 NDR_CHECK(ndr_pull_align(ndr, 4));
4495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4497                 if (_ptr_printer_name) {
4498                         NDR_PULL_ALLOC(ndr, r->printer_name);
4499                 } else {
4500                         r->printer_name = NULL;
4501                 }
4502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4503                 if (_ptr_server_name) {
4504                         NDR_PULL_ALLOC(ndr, r->server_name);
4505                 } else {
4506                         r->server_name = NULL;
4507                 }
4508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4509                 if (_ptr_user_name) {
4510                         NDR_PULL_ALLOC(ndr, r->user_name);
4511                 } else {
4512                         r->user_name = NULL;
4513                 }
4514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4515                 if (_ptr_document_name) {
4516                         NDR_PULL_ALLOC(ndr, r->document_name);
4517                 } else {
4518                         r->document_name = NULL;
4519                 }
4520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4521                 if (_ptr_data_type) {
4522                         NDR_PULL_ALLOC(ndr, r->data_type);
4523                 } else {
4524                         r->data_type = NULL;
4525                 }
4526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4527                 if (_ptr_text_status) {
4528                         NDR_PULL_ALLOC(ndr, r->text_status);
4529                 } else {
4530                         r->text_status = NULL;
4531                 }
4532                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4534                 if (r->priority > 99) {
4535                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4536                 }
4537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4540                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4541         }
4542         if (ndr_flags & NDR_BUFFERS) {
4543                 if (r->printer_name) {
4544                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4545                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4546                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4547                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4548                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
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->printer_name), ndr_get_array_length(ndr, &r->printer_name));
4550                         }
4551                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4552                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4554                 }
4555                 if (r->server_name) {
4556                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4557                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4558                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4559                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4560                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4561                                 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));
4562                         }
4563                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4564                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4566                 }
4567                 if (r->user_name) {
4568                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4569                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4572                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4573                                 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));
4574                         }
4575                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4578                 }
4579                 if (r->document_name) {
4580                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4581                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4582                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4583                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4584                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4585                                 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));
4586                         }
4587                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4588                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4590                 }
4591                 if (r->data_type) {
4592                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4593                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4596                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4597                                 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));
4598                         }
4599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4602                 }
4603                 if (r->text_status) {
4604                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4605                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4606                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4607                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4608                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4609                                 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));
4610                         }
4611                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4612                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4614                 }
4615         }
4616         return NDR_ERR_SUCCESS;
4617 }
4618
4619 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4620 {
4621         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4622         ndr->depth++;
4623         ndr_print_uint32(ndr, "job_id", r->job_id);
4624         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4625         ndr->depth++;
4626         if (r->printer_name) {
4627                 ndr_print_string(ndr, "printer_name", r->printer_name);
4628         }
4629         ndr->depth--;
4630         ndr_print_ptr(ndr, "server_name", r->server_name);
4631         ndr->depth++;
4632         if (r->server_name) {
4633                 ndr_print_string(ndr, "server_name", r->server_name);
4634         }
4635         ndr->depth--;
4636         ndr_print_ptr(ndr, "user_name", r->user_name);
4637         ndr->depth++;
4638         if (r->user_name) {
4639                 ndr_print_string(ndr, "user_name", r->user_name);
4640         }
4641         ndr->depth--;
4642         ndr_print_ptr(ndr, "document_name", r->document_name);
4643         ndr->depth++;
4644         if (r->document_name) {
4645                 ndr_print_string(ndr, "document_name", r->document_name);
4646         }
4647         ndr->depth--;
4648         ndr_print_ptr(ndr, "data_type", r->data_type);
4649         ndr->depth++;
4650         if (r->data_type) {
4651                 ndr_print_string(ndr, "data_type", r->data_type);
4652         }
4653         ndr->depth--;
4654         ndr_print_ptr(ndr, "text_status", r->text_status);
4655         ndr->depth++;
4656         if (r->text_status) {
4657                 ndr_print_string(ndr, "text_status", r->text_status);
4658         }
4659         ndr->depth--;
4660         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4661         ndr_print_uint32(ndr, "priority", r->priority);
4662         ndr_print_uint32(ndr, "position", r->position);
4663         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4664         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4665         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4666         ndr->depth--;
4667 }
4668
4669 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4670 {
4671         if (ndr_flags & NDR_SCALARS) {
4672                 NDR_CHECK(ndr_push_align(ndr, 4));
4673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4682                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4686                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4693                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4696         }
4697         if (ndr_flags & NDR_BUFFERS) {
4698                 if (r->printer_name) {
4699                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4700                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4702                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4703                 }
4704                 if (r->server_name) {
4705                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4708                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4709                 }
4710                 if (r->user_name) {
4711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4714                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4715                 }
4716                 if (r->document_name) {
4717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4720                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4721                 }
4722                 if (r->notify_name) {
4723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4727                 }
4728                 if (r->data_type) {
4729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4732                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4733                 }
4734                 if (r->print_processor) {
4735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4739                 }
4740                 if (r->parameters) {
4741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4744                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4745                 }
4746                 if (r->driver_name) {
4747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4751                 }
4752                 if (r->text_status) {
4753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4756                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4757                 }
4758         }
4759         return NDR_ERR_SUCCESS;
4760 }
4761
4762 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4763 {
4764         uint32_t _ptr_printer_name;
4765         TALLOC_CTX *_mem_save_printer_name_0;
4766         uint32_t _ptr_server_name;
4767         TALLOC_CTX *_mem_save_server_name_0;
4768         uint32_t _ptr_user_name;
4769         TALLOC_CTX *_mem_save_user_name_0;
4770         uint32_t _ptr_document_name;
4771         TALLOC_CTX *_mem_save_document_name_0;
4772         uint32_t _ptr_notify_name;
4773         TALLOC_CTX *_mem_save_notify_name_0;
4774         uint32_t _ptr_data_type;
4775         TALLOC_CTX *_mem_save_data_type_0;
4776         uint32_t _ptr_print_processor;
4777         TALLOC_CTX *_mem_save_print_processor_0;
4778         uint32_t _ptr_parameters;
4779         TALLOC_CTX *_mem_save_parameters_0;
4780         uint32_t _ptr_driver_name;
4781         TALLOC_CTX *_mem_save_driver_name_0;
4782         uint32_t _ptr_text_status;
4783         TALLOC_CTX *_mem_save_text_status_0;
4784         if (ndr_flags & NDR_SCALARS) {
4785                 NDR_CHECK(ndr_pull_align(ndr, 4));
4786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4787                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4788                 if (_ptr_printer_name) {
4789                         NDR_PULL_ALLOC(ndr, r->printer_name);
4790                 } else {
4791                         r->printer_name = NULL;
4792                 }
4793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4794                 if (_ptr_server_name) {
4795                         NDR_PULL_ALLOC(ndr, r->server_name);
4796                 } else {
4797                         r->server_name = NULL;
4798                 }
4799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4800                 if (_ptr_user_name) {
4801                         NDR_PULL_ALLOC(ndr, r->user_name);
4802                 } else {
4803                         r->user_name = NULL;
4804                 }
4805                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4806                 if (_ptr_document_name) {
4807                         NDR_PULL_ALLOC(ndr, r->document_name);
4808                 } else {
4809                         r->document_name = NULL;
4810                 }
4811                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4812                 if (_ptr_notify_name) {
4813                         NDR_PULL_ALLOC(ndr, r->notify_name);
4814                 } else {
4815                         r->notify_name = NULL;
4816                 }
4817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4818                 if (_ptr_data_type) {
4819                         NDR_PULL_ALLOC(ndr, r->data_type);
4820                 } else {
4821                         r->data_type = NULL;
4822                 }
4823                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4824                 if (_ptr_print_processor) {
4825                         NDR_PULL_ALLOC(ndr, r->print_processor);
4826                 } else {
4827                         r->print_processor = NULL;
4828                 }
4829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4830                 if (_ptr_parameters) {
4831                         NDR_PULL_ALLOC(ndr, r->parameters);
4832                 } else {
4833                         r->parameters = NULL;
4834                 }
4835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4836                 if (_ptr_driver_name) {
4837                         NDR_PULL_ALLOC(ndr, r->driver_name);
4838                 } else {
4839                         r->driver_name = NULL;
4840                 }
4841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4843                 if (_ptr_text_status) {
4844                         NDR_PULL_ALLOC(ndr, r->text_status);
4845                 } else {
4846                         r->text_status = NULL;
4847                 }
4848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4849                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4851                 if (r->priority > 99) {
4852                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4853                 }
4854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4859                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4862         }
4863         if (ndr_flags & NDR_BUFFERS) {
4864                 if (r->printer_name) {
4865                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4866                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4868                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4869                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4870                                 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));
4871                         }
4872                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4873                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4875                 }
4876                 if (r->server_name) {
4877                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4878                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4879                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4880                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4881                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4882                                 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));
4883                         }
4884                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4885                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4886                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4887                 }
4888                 if (r->user_name) {
4889                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4890                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4891                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4892                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4893                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4894                                 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));
4895                         }
4896                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4897                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4899                 }
4900                 if (r->document_name) {
4901                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4902                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4903                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4904                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4905                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4906                                 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));
4907                         }
4908                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4909                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4910                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4911                 }
4912                 if (r->notify_name) {
4913                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4914                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4915                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4916                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4917                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4918                                 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));
4919                         }
4920                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4921                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4923                 }
4924                 if (r->data_type) {
4925                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4926                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4929                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4930                                 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));
4931                         }
4932                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4933                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4935                 }
4936                 if (r->print_processor) {
4937                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4938                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4940                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4941                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4942                                 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));
4943                         }
4944                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4945                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4947                 }
4948                 if (r->parameters) {
4949                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4950                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4951                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4952                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4953                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4954                                 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));
4955                         }
4956                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4957                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4959                 }
4960                 if (r->driver_name) {
4961                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4962                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4965                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4966                                 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));
4967                         }
4968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4969                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4971                 }
4972                 if (r->text_status) {
4973                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4974                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4976                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4977                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4978                                 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));
4979                         }
4980                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4983                 }
4984         }
4985         return NDR_ERR_SUCCESS;
4986 }
4987
4988 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4989 {
4990         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4991         ndr->depth++;
4992         ndr_print_uint32(ndr, "job_id", r->job_id);
4993         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4994         ndr->depth++;
4995         if (r->printer_name) {
4996                 ndr_print_string(ndr, "printer_name", r->printer_name);
4997         }
4998         ndr->depth--;
4999         ndr_print_ptr(ndr, "server_name", r->server_name);
5000         ndr->depth++;
5001         if (r->server_name) {
5002                 ndr_print_string(ndr, "server_name", r->server_name);
5003         }
5004         ndr->depth--;
5005         ndr_print_ptr(ndr, "user_name", r->user_name);
5006         ndr->depth++;
5007         if (r->user_name) {
5008                 ndr_print_string(ndr, "user_name", r->user_name);
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "document_name", r->document_name);
5012         ndr->depth++;
5013         if (r->document_name) {
5014                 ndr_print_string(ndr, "document_name", r->document_name);
5015         }
5016         ndr->depth--;
5017         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5018         ndr->depth++;
5019         if (r->notify_name) {
5020                 ndr_print_string(ndr, "notify_name", r->notify_name);
5021         }
5022         ndr->depth--;
5023         ndr_print_ptr(ndr, "data_type", r->data_type);
5024         ndr->depth++;
5025         if (r->data_type) {
5026                 ndr_print_string(ndr, "data_type", r->data_type);
5027         }
5028         ndr->depth--;
5029         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5030         ndr->depth++;
5031         if (r->print_processor) {
5032                 ndr_print_string(ndr, "print_processor", r->print_processor);
5033         }
5034         ndr->depth--;
5035         ndr_print_ptr(ndr, "parameters", r->parameters);
5036         ndr->depth++;
5037         if (r->parameters) {
5038                 ndr_print_string(ndr, "parameters", r->parameters);
5039         }
5040         ndr->depth--;
5041         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5042         ndr->depth++;
5043         if (r->driver_name) {
5044                 ndr_print_string(ndr, "driver_name", r->driver_name);
5045         }
5046         ndr->depth--;
5047         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5048         ndr_print_ptr(ndr, "text_status", r->text_status);
5049         ndr->depth++;
5050         if (r->text_status) {
5051                 ndr_print_string(ndr, "text_status", r->text_status);
5052         }
5053         ndr->depth--;
5054         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5055         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5056         ndr_print_uint32(ndr, "priority", r->priority);
5057         ndr_print_uint32(ndr, "position", r->position);
5058         ndr_print_uint32(ndr, "start_time", r->start_time);
5059         ndr_print_uint32(ndr, "until_time", r->until_time);
5060         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5061         ndr_print_uint32(ndr, "size", r->size);
5062         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5063         ndr_print_uint32(ndr, "time", r->time);
5064         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5065         ndr->depth--;
5066 }
5067
5068 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5069 {
5070         if (ndr_flags & NDR_SCALARS) {
5071                 NDR_CHECK(ndr_push_align(ndr, 4));
5072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5080                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5083                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5085                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5092                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5096         }
5097         if (ndr_flags & NDR_BUFFERS) {
5098                 if (r->printer_name) {
5099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5103                 }
5104                 if (r->server_name) {
5105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5109                 }
5110                 if (r->user_name) {
5111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5115                 }
5116                 if (r->document_name) {
5117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5121                 }
5122                 if (r->notify_name) {
5123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5127                 }
5128                 if (r->data_type) {
5129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5133                 }
5134                 if (r->print_processor) {
5135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5139                 }
5140                 if (r->parameters) {
5141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5144                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5145                 }
5146                 if (r->driver_name) {
5147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5149                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5150                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5151                 }
5152                 if (r->text_status) {
5153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5156                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5157                 }
5158         }
5159         return NDR_ERR_SUCCESS;
5160 }
5161
5162 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5163 {
5164         uint32_t _ptr_printer_name;
5165         TALLOC_CTX *_mem_save_printer_name_0;
5166         uint32_t _ptr_server_name;
5167         TALLOC_CTX *_mem_save_server_name_0;
5168         uint32_t _ptr_user_name;
5169         TALLOC_CTX *_mem_save_user_name_0;
5170         uint32_t _ptr_document_name;
5171         TALLOC_CTX *_mem_save_document_name_0;
5172         uint32_t _ptr_notify_name;
5173         TALLOC_CTX *_mem_save_notify_name_0;
5174         uint32_t _ptr_data_type;
5175         TALLOC_CTX *_mem_save_data_type_0;
5176         uint32_t _ptr_print_processor;
5177         TALLOC_CTX *_mem_save_print_processor_0;
5178         uint32_t _ptr_parameters;
5179         TALLOC_CTX *_mem_save_parameters_0;
5180         uint32_t _ptr_driver_name;
5181         TALLOC_CTX *_mem_save_driver_name_0;
5182         uint32_t _ptr_text_status;
5183         TALLOC_CTX *_mem_save_text_status_0;
5184         if (ndr_flags & NDR_SCALARS) {
5185                 NDR_CHECK(ndr_pull_align(ndr, 4));
5186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5188                 if (_ptr_printer_name) {
5189                         NDR_PULL_ALLOC(ndr, r->printer_name);
5190                 } else {
5191                         r->printer_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5194                 if (_ptr_server_name) {
5195                         NDR_PULL_ALLOC(ndr, r->server_name);
5196                 } else {
5197                         r->server_name = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5200                 if (_ptr_user_name) {
5201                         NDR_PULL_ALLOC(ndr, r->user_name);
5202                 } else {
5203                         r->user_name = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5206                 if (_ptr_document_name) {
5207                         NDR_PULL_ALLOC(ndr, r->document_name);
5208                 } else {
5209                         r->document_name = NULL;
5210                 }
5211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5212                 if (_ptr_notify_name) {
5213                         NDR_PULL_ALLOC(ndr, r->notify_name);
5214                 } else {
5215                         r->notify_name = NULL;
5216                 }
5217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5218                 if (_ptr_data_type) {
5219                         NDR_PULL_ALLOC(ndr, r->data_type);
5220                 } else {
5221                         r->data_type = NULL;
5222                 }
5223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5224                 if (_ptr_print_processor) {
5225                         NDR_PULL_ALLOC(ndr, r->print_processor);
5226                 } else {
5227                         r->print_processor = NULL;
5228                 }
5229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5230                 if (_ptr_parameters) {
5231                         NDR_PULL_ALLOC(ndr, r->parameters);
5232                 } else {
5233                         r->parameters = NULL;
5234                 }
5235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5236                 if (_ptr_driver_name) {
5237                         NDR_PULL_ALLOC(ndr, r->driver_name);
5238                 } else {
5239                         r->driver_name = NULL;
5240                 }
5241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5243                 if (_ptr_text_status) {
5244                         NDR_PULL_ALLOC(ndr, r->text_status);
5245                 } else {
5246                         r->text_status = NULL;
5247                 }
5248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5249                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5251                 if (r->priority > 99) {
5252                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5253                 }
5254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5259                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5263         }
5264         if (ndr_flags & NDR_BUFFERS) {
5265                 if (r->printer_name) {
5266                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5267                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5270                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5271                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5272                         }
5273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5276                 }
5277                 if (r->server_name) {
5278                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5279                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5282                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5283                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5284                         }
5285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5288                 }
5289                 if (r->user_name) {
5290                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5291                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5292                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5293                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5294                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5295                                 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));
5296                         }
5297                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5298                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5300                 }
5301                 if (r->document_name) {
5302                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5303                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5304                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5305                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5306                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5307                                 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));
5308                         }
5309                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5310                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5312                 }
5313                 if (r->notify_name) {
5314                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5315                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5316                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5317                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5318                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5319                                 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));
5320                         }
5321                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5322                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5324                 }
5325                 if (r->data_type) {
5326                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5327                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5329                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5330                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5331                                 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));
5332                         }
5333                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5334                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5336                 }
5337                 if (r->print_processor) {
5338                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5339                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5341                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5342                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5343                                 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));
5344                         }
5345                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5346                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5348                 }
5349                 if (r->parameters) {
5350                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5351                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5353                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5354                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5355                                 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));
5356                         }
5357                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5358                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5360                 }
5361                 if (r->driver_name) {
5362                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5363                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5366                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5367                                 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));
5368                         }
5369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5372                 }
5373                 if (r->text_status) {
5374                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5375                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5377                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5378                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5379                                 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));
5380                         }
5381                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5382                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5384                 }
5385         }
5386         return NDR_ERR_SUCCESS;
5387 }
5388
5389 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5390 {
5391         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5392         ndr->depth++;
5393         ndr_print_uint32(ndr, "job_id", r->job_id);
5394         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5395         ndr->depth++;
5396         if (r->printer_name) {
5397                 ndr_print_string(ndr, "printer_name", r->printer_name);
5398         }
5399         ndr->depth--;
5400         ndr_print_ptr(ndr, "server_name", r->server_name);
5401         ndr->depth++;
5402         if (r->server_name) {
5403                 ndr_print_string(ndr, "server_name", r->server_name);
5404         }
5405         ndr->depth--;
5406         ndr_print_ptr(ndr, "user_name", r->user_name);
5407         ndr->depth++;
5408         if (r->user_name) {
5409                 ndr_print_string(ndr, "user_name", r->user_name);
5410         }
5411         ndr->depth--;
5412         ndr_print_ptr(ndr, "document_name", r->document_name);
5413         ndr->depth++;
5414         if (r->document_name) {
5415                 ndr_print_string(ndr, "document_name", r->document_name);
5416         }
5417         ndr->depth--;
5418         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5419         ndr->depth++;
5420         if (r->notify_name) {
5421                 ndr_print_string(ndr, "notify_name", r->notify_name);
5422         }
5423         ndr->depth--;
5424         ndr_print_ptr(ndr, "data_type", r->data_type);
5425         ndr->depth++;
5426         if (r->data_type) {
5427                 ndr_print_string(ndr, "data_type", r->data_type);
5428         }
5429         ndr->depth--;
5430         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5431         ndr->depth++;
5432         if (r->print_processor) {
5433                 ndr_print_string(ndr, "print_processor", r->print_processor);
5434         }
5435         ndr->depth--;
5436         ndr_print_ptr(ndr, "parameters", r->parameters);
5437         ndr->depth++;
5438         if (r->parameters) {
5439                 ndr_print_string(ndr, "parameters", r->parameters);
5440         }
5441         ndr->depth--;
5442         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5443         ndr->depth++;
5444         if (r->driver_name) {
5445                 ndr_print_string(ndr, "driver_name", r->driver_name);
5446         }
5447         ndr->depth--;
5448         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5449         ndr_print_ptr(ndr, "text_status", r->text_status);
5450         ndr->depth++;
5451         if (r->text_status) {
5452                 ndr_print_string(ndr, "text_status", r->text_status);
5453         }
5454         ndr->depth--;
5455         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5456         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5457         ndr_print_uint32(ndr, "priority", r->priority);
5458         ndr_print_uint32(ndr, "position", r->position);
5459         ndr_print_uint32(ndr, "start_time", r->start_time);
5460         ndr_print_uint32(ndr, "until_time", r->until_time);
5461         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5462         ndr_print_uint32(ndr, "size", r->size);
5463         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5464         ndr_print_uint32(ndr, "time", r->time);
5465         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5466         ndr_print_uint32(ndr, "size_high", r->size_high);
5467         ndr->depth--;
5468 }
5469
5470 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5471 {
5472         if (ndr_flags & NDR_SCALARS) {
5473                 int level = ndr_push_get_switch_value(ndr, r);
5474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5475                 switch (level) {
5476                         case 1: {
5477                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5478                         break; }
5479
5480                         case 2: {
5481                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5482                         break; }
5483
5484                         case 3: {
5485                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5486                         break; }
5487
5488                         case 4: {
5489                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5490                         break; }
5491
5492                         default: {
5493                         break; }
5494
5495                 }
5496         }
5497         if (ndr_flags & NDR_BUFFERS) {
5498                 int level = ndr_push_get_switch_value(ndr, r);
5499                 switch (level) {
5500                         case 1:
5501                                 if (r->info1) {
5502                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5503                                 }
5504                         break;
5505
5506                         case 2:
5507                                 if (r->info2) {
5508                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5509                                 }
5510                         break;
5511
5512                         case 3:
5513                                 if (r->info3) {
5514                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5515                                 }
5516                         break;
5517
5518                         case 4:
5519                                 if (r->info4) {
5520                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5521                                 }
5522                         break;
5523
5524                         default:
5525                         break;
5526
5527                 }
5528         }
5529         return NDR_ERR_SUCCESS;
5530 }
5531
5532 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5533 {
5534         int level;
5535         uint32_t _level;
5536         TALLOC_CTX *_mem_save_info1_0;
5537         TALLOC_CTX *_mem_save_info2_0;
5538         TALLOC_CTX *_mem_save_info3_0;
5539         TALLOC_CTX *_mem_save_info4_0;
5540         level = ndr_pull_get_switch_value(ndr, r);
5541         if (ndr_flags & NDR_SCALARS) {
5542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5543                 if (_level != level) {
5544                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5545                 }
5546                 switch (level) {
5547                         case 1: {
5548                                 uint32_t _ptr_info1;
5549                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5550                                 if (_ptr_info1) {
5551                                         NDR_PULL_ALLOC(ndr, r->info1);
5552                                 } else {
5553                                         r->info1 = NULL;
5554                                 }
5555                         break; }
5556
5557                         case 2: {
5558                                 uint32_t _ptr_info2;
5559                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5560                                 if (_ptr_info2) {
5561                                         NDR_PULL_ALLOC(ndr, r->info2);
5562                                 } else {
5563                                         r->info2 = NULL;
5564                                 }
5565                         break; }
5566
5567                         case 3: {
5568                                 uint32_t _ptr_info3;
5569                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5570                                 if (_ptr_info3) {
5571                                         NDR_PULL_ALLOC(ndr, r->info3);
5572                                 } else {
5573                                         r->info3 = NULL;
5574                                 }
5575                         break; }
5576
5577                         case 4: {
5578                                 uint32_t _ptr_info4;
5579                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5580                                 if (_ptr_info4) {
5581                                         NDR_PULL_ALLOC(ndr, r->info4);
5582                                 } else {
5583                                         r->info4 = NULL;
5584                                 }
5585                         break; }
5586
5587                         default: {
5588                         break; }
5589
5590                 }
5591         }
5592         if (ndr_flags & NDR_BUFFERS) {
5593                 switch (level) {
5594                         case 1:
5595                                 if (r->info1) {
5596                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5597                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5598                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5599                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5600                                 }
5601                         break;
5602
5603                         case 2:
5604                                 if (r->info2) {
5605                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5606                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5607                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5608                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5609                                 }
5610                         break;
5611
5612                         case 3:
5613                                 if (r->info3) {
5614                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5615                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5616                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5617                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5618                                 }
5619                         break;
5620
5621                         case 4:
5622                                 if (r->info4) {
5623                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5624                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5625                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5626                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5627                                 }
5628                         break;
5629
5630                         default:
5631                         break;
5632
5633                 }
5634         }
5635         return NDR_ERR_SUCCESS;
5636 }
5637
5638 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5639 {
5640         int level;
5641         level = ndr_print_get_switch_value(ndr, r);
5642         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5643         switch (level) {
5644                 case 1:
5645                         ndr_print_ptr(ndr, "info1", r->info1);
5646                         ndr->depth++;
5647                         if (r->info1) {
5648                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5649                         }
5650                         ndr->depth--;
5651                 break;
5652
5653                 case 2:
5654                         ndr_print_ptr(ndr, "info2", r->info2);
5655                         ndr->depth++;
5656                         if (r->info2) {
5657                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5658                         }
5659                         ndr->depth--;
5660                 break;
5661
5662                 case 3:
5663                         ndr_print_ptr(ndr, "info3", r->info3);
5664                         ndr->depth++;
5665                         if (r->info3) {
5666                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5667                         }
5668                         ndr->depth--;
5669                 break;
5670
5671                 case 4:
5672                         ndr_print_ptr(ndr, "info4", r->info4);
5673                         ndr->depth++;
5674                         if (r->info4) {
5675                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5676                         }
5677                         ndr->depth--;
5678                 break;
5679
5680                 default:
5681                 break;
5682
5683         }
5684 }
5685
5686 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5687 {
5688         if (ndr_flags & NDR_SCALARS) {
5689                 NDR_CHECK(ndr_push_align(ndr, 4));
5690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5691                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5692                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5693         }
5694         if (ndr_flags & NDR_BUFFERS) {
5695                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5696         }
5697         return NDR_ERR_SUCCESS;
5698 }
5699
5700 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5701 {
5702         if (ndr_flags & NDR_SCALARS) {
5703                 NDR_CHECK(ndr_pull_align(ndr, 4));
5704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5705                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5706                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5707         }
5708         if (ndr_flags & NDR_BUFFERS) {
5709                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5710         }
5711         return NDR_ERR_SUCCESS;
5712 }
5713
5714 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5715 {
5716         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5717         ndr->depth++;
5718         ndr_print_uint32(ndr, "level", r->level);
5719         ndr_print_set_switch_value(ndr, &r->info, r->level);
5720         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5721         ndr->depth--;
5722 }
5723
5724 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5725 {
5726         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5727         return NDR_ERR_SUCCESS;
5728 }
5729
5730 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5731 {
5732         uint32_t v;
5733         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5734         *r = v;
5735         return NDR_ERR_SUCCESS;
5736 }
5737
5738 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5739 {
5740         const char *val = NULL;
5741
5742         switch (r) {
5743                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5744                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5745                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5746                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5747                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5748                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5749                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5750                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5751                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5752         }
5753         ndr_print_enum(ndr, name, "ENUM", val, r);
5754 }
5755
5756 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5757 {
5758         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5759         return NDR_ERR_SUCCESS;
5760 }
5761
5762 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5763 {
5764         uint32_t v;
5765         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5766         *r = v;
5767         return NDR_ERR_SUCCESS;
5768 }
5769
5770 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5771 {
5772         const char *val = NULL;
5773
5774         switch (r) {
5775                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5776                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5777                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5778                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5779                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5780         }
5781         ndr_print_enum(ndr, name, "ENUM", val, r);
5782 }
5783
5784 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5785 {
5786         if (ndr_flags & NDR_SCALARS) {
5787                 NDR_CHECK(ndr_push_align(ndr, 4));
5788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5793                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5805                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5808                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5812                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5813                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5817         }
5818         if (ndr_flags & NDR_BUFFERS) {
5819                 if (r->servername) {
5820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5824                 }
5825                 if (r->printername) {
5826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5830                 }
5831         }
5832         return NDR_ERR_SUCCESS;
5833 }
5834
5835 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5836 {
5837         uint32_t _ptr_servername;
5838         TALLOC_CTX *_mem_save_servername_0;
5839         uint32_t _ptr_printername;
5840         TALLOC_CTX *_mem_save_printername_0;
5841         if (ndr_flags & NDR_SCALARS) {
5842                 NDR_CHECK(ndr_pull_align(ndr, 4));
5843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5844                 if (_ptr_servername) {
5845                         NDR_PULL_ALLOC(ndr, r->servername);
5846                 } else {
5847                         r->servername = NULL;
5848                 }
5849                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5850                 if (_ptr_printername) {
5851                         NDR_PULL_ALLOC(ndr, r->printername);
5852                 } else {
5853                         r->printername = NULL;
5854                 }
5855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5858                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5870                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5873                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5877                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5878                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5882         }
5883         if (ndr_flags & NDR_BUFFERS) {
5884                 if (r->servername) {
5885                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5886                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5887                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5888                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5889                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5890                                 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));
5891                         }
5892                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5893                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5895                 }
5896                 if (r->printername) {
5897                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5898                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5899                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5900                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5901                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5902                                 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));
5903                         }
5904                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5905                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5907                 }
5908         }
5909         return NDR_ERR_SUCCESS;
5910 }
5911
5912 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5913 {
5914         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5915         ndr->depth++;
5916         ndr_print_ptr(ndr, "servername", r->servername);
5917         ndr->depth++;
5918         if (r->servername) {
5919                 ndr_print_string(ndr, "servername", r->servername);
5920         }
5921         ndr->depth--;
5922         ndr_print_ptr(ndr, "printername", r->printername);
5923         ndr->depth++;
5924         if (r->printername) {
5925                 ndr_print_string(ndr, "printername", r->printername);
5926         }
5927         ndr->depth--;
5928         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5929         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5930         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5931         ndr_print_spoolss_Time(ndr, "time", &r->time);
5932         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5933         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5934         ndr_print_uint32(ndr, "version", r->version);
5935         ndr_print_uint32(ndr, "free_build", r->free_build);
5936         ndr_print_uint32(ndr, "spooling", r->spooling);
5937         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5938         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5939         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5940         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5941         ndr_print_uint32(ndr, "job_error", r->job_error);
5942         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5943         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5944         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5945         ndr_print_uint32(ndr, "change_id", r->change_id);
5946         ndr_print_WERROR(ndr, "last_error", r->last_error);
5947         ndr_print_uint32(ndr, "status", r->status);
5948         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5949         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5950         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5951         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5952         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5953         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5954         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5955         ndr->depth--;
5956 }
5957
5958 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5959 {
5960         if (ndr_flags & NDR_SCALARS) {
5961                 NDR_CHECK(ndr_push_align(ndr, 4));
5962                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5966         }
5967         if (ndr_flags & NDR_BUFFERS) {
5968                 if (r->description) {
5969                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5970                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5973                 }
5974                 if (r->name) {
5975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5979                 }
5980                 if (r->comment) {
5981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5984                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5985                 }
5986         }
5987         return NDR_ERR_SUCCESS;
5988 }
5989
5990 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5991 {
5992         uint32_t _ptr_description;
5993         TALLOC_CTX *_mem_save_description_0;
5994         uint32_t _ptr_name;
5995         TALLOC_CTX *_mem_save_name_0;
5996         uint32_t _ptr_comment;
5997         TALLOC_CTX *_mem_save_comment_0;
5998         if (ndr_flags & NDR_SCALARS) {
5999                 NDR_CHECK(ndr_pull_align(ndr, 4));
6000                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
6001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6002                 if (_ptr_description) {
6003                         NDR_PULL_ALLOC(ndr, r->description);
6004                 } else {
6005                         r->description = NULL;
6006                 }
6007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6008                 if (_ptr_name) {
6009                         NDR_PULL_ALLOC(ndr, r->name);
6010                 } else {
6011                         r->name = NULL;
6012                 }
6013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6014                 if (_ptr_comment) {
6015                         NDR_PULL_ALLOC(ndr, r->comment);
6016                 } else {
6017                         r->comment = NULL;
6018                 }
6019         }
6020         if (ndr_flags & NDR_BUFFERS) {
6021                 if (r->description) {
6022                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6023                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6026                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6027                                 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));
6028                         }
6029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6032                 }
6033                 if (r->name) {
6034                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6035                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6038                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6039                                 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));
6040                         }
6041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6044                 }
6045                 if (r->comment) {
6046                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6047                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6050                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6051                                 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));
6052                         }
6053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6056                 }
6057         }
6058         return NDR_ERR_SUCCESS;
6059 }
6060
6061 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6062 {
6063         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6064         ndr->depth++;
6065         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
6066         ndr_print_ptr(ndr, "description", r->description);
6067         ndr->depth++;
6068         if (r->description) {
6069                 ndr_print_string(ndr, "description", r->description);
6070         }
6071         ndr->depth--;
6072         ndr_print_ptr(ndr, "name", r->name);
6073         ndr->depth++;
6074         if (r->name) {
6075                 ndr_print_string(ndr, "name", r->name);
6076         }
6077         ndr->depth--;
6078         ndr_print_ptr(ndr, "comment", r->comment);
6079         ndr->depth++;
6080         if (r->comment) {
6081                 ndr_print_string(ndr, "comment", r->comment);
6082         }
6083         ndr->depth--;
6084         ndr->depth--;
6085 }
6086
6087 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6088 {
6089         if (ndr_flags & NDR_SCALARS) {
6090                 NDR_CHECK(ndr_push_align(ndr, 4));
6091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6095                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6096                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6103                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6104                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6109                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6112         }
6113         if (ndr_flags & NDR_BUFFERS) {
6114                 if (r->servername) {
6115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6118                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6119                 }
6120                 if (r->printername) {
6121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6125                 }
6126                 if (r->sharename) {
6127                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6128                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6130                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6131                 }
6132                 if (r->portname) {
6133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6136                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6137                 }
6138                 if (r->drivername) {
6139                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6140                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6142                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6143                 }
6144                 if (r->comment) {
6145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6148                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6149                 }
6150                 if (r->location) {
6151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6154                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6155                 }
6156                 if (r->devmode) {
6157                         {
6158                                 struct ndr_push *_ndr_devmode;
6159                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6160                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6161                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6162                         }
6163                 }
6164                 if (r->sepfile) {
6165                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6168                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6169                 }
6170                 if (r->printprocessor) {
6171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6174                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6175                 }
6176                 if (r->datatype) {
6177                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6180                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6181                 }
6182                 if (r->parameters) {
6183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6186                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6187                 }
6188                 if (r->secdesc) {
6189                         {
6190                                 struct ndr_push *_ndr_secdesc;
6191                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6192                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6193                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6194                         }
6195                 }
6196         }
6197         return NDR_ERR_SUCCESS;
6198 }
6199
6200 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6201 {
6202         uint32_t _ptr_servername;
6203         TALLOC_CTX *_mem_save_servername_0;
6204         uint32_t _ptr_printername;
6205         TALLOC_CTX *_mem_save_printername_0;
6206         uint32_t _ptr_sharename;
6207         TALLOC_CTX *_mem_save_sharename_0;
6208         uint32_t _ptr_portname;
6209         TALLOC_CTX *_mem_save_portname_0;
6210         uint32_t _ptr_drivername;
6211         TALLOC_CTX *_mem_save_drivername_0;
6212         uint32_t _ptr_comment;
6213         TALLOC_CTX *_mem_save_comment_0;
6214         uint32_t _ptr_location;
6215         TALLOC_CTX *_mem_save_location_0;
6216         uint32_t _ptr_devmode;
6217         TALLOC_CTX *_mem_save_devmode_0;
6218         uint32_t _ptr_sepfile;
6219         TALLOC_CTX *_mem_save_sepfile_0;
6220         uint32_t _ptr_printprocessor;
6221         TALLOC_CTX *_mem_save_printprocessor_0;
6222         uint32_t _ptr_datatype;
6223         TALLOC_CTX *_mem_save_datatype_0;
6224         uint32_t _ptr_parameters;
6225         TALLOC_CTX *_mem_save_parameters_0;
6226         uint32_t _ptr_secdesc;
6227         TALLOC_CTX *_mem_save_secdesc_0;
6228         if (ndr_flags & NDR_SCALARS) {
6229                 NDR_CHECK(ndr_pull_align(ndr, 4));
6230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6231                 if (_ptr_servername) {
6232                         NDR_PULL_ALLOC(ndr, r->servername);
6233                 } else {
6234                         r->servername = NULL;
6235                 }
6236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6237                 if (_ptr_printername) {
6238                         NDR_PULL_ALLOC(ndr, r->printername);
6239                 } else {
6240                         r->printername = NULL;
6241                 }
6242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6243                 if (_ptr_sharename) {
6244                         NDR_PULL_ALLOC(ndr, r->sharename);
6245                 } else {
6246                         r->sharename = NULL;
6247                 }
6248                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6249                 if (_ptr_portname) {
6250                         NDR_PULL_ALLOC(ndr, r->portname);
6251                 } else {
6252                         r->portname = NULL;
6253                 }
6254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6255                 if (_ptr_drivername) {
6256                         NDR_PULL_ALLOC(ndr, r->drivername);
6257                 } else {
6258                         r->drivername = NULL;
6259                 }
6260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6261                 if (_ptr_comment) {
6262                         NDR_PULL_ALLOC(ndr, r->comment);
6263                 } else {
6264                         r->comment = NULL;
6265                 }
6266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6267                 if (_ptr_location) {
6268                         NDR_PULL_ALLOC(ndr, r->location);
6269                 } else {
6270                         r->location = NULL;
6271                 }
6272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6273                 if (_ptr_devmode) {
6274                         NDR_PULL_ALLOC(ndr, r->devmode);
6275                 } else {
6276                         r->devmode = NULL;
6277                 }
6278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6279                 if (_ptr_sepfile) {
6280                         NDR_PULL_ALLOC(ndr, r->sepfile);
6281                 } else {
6282                         r->sepfile = NULL;
6283                 }
6284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6285                 if (_ptr_printprocessor) {
6286                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6287                 } else {
6288                         r->printprocessor = NULL;
6289                 }
6290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6291                 if (_ptr_datatype) {
6292                         NDR_PULL_ALLOC(ndr, r->datatype);
6293                 } else {
6294                         r->datatype = NULL;
6295                 }
6296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6297                 if (_ptr_parameters) {
6298                         NDR_PULL_ALLOC(ndr, r->parameters);
6299                 } else {
6300                         r->parameters = NULL;
6301                 }
6302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6303                 if (_ptr_secdesc) {
6304                         NDR_PULL_ALLOC(ndr, r->secdesc);
6305                 } else {
6306                         r->secdesc = NULL;
6307                 }
6308                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6310                 if (r->priority > 99) {
6311                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6312                 }
6313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6316                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6319         }
6320         if (ndr_flags & NDR_BUFFERS) {
6321                 if (r->servername) {
6322                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6323                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6324                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6325                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6326                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6327                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6328                         }
6329                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6330                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6332                 }
6333                 if (r->printername) {
6334                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6335                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6338                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6339                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6340                         }
6341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6344                 }
6345                 if (r->sharename) {
6346                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6347                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6350                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6351                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
6352                         }
6353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6356                 }
6357                 if (r->portname) {
6358                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6359                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6362                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6363                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6364                         }
6365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6368                 }
6369                 if (r->drivername) {
6370                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6371                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6374                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6375                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
6376                         }
6377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6380                 }
6381                 if (r->comment) {
6382                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6383                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6386                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6387                                 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));
6388                         }
6389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6392                 }
6393                 if (r->location) {
6394                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6395                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6398                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6399                                 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));
6400                         }
6401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6402                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6404                 }
6405                 if (r->devmode) {
6406                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6407                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6408                         {
6409                                 struct ndr_pull *_ndr_devmode;
6410                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6411                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6412                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6413                         }
6414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6415                 }
6416                 if (r->sepfile) {
6417                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6418                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6419                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6420                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6421                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6422                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
6423                         }
6424                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6425                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6427                 }
6428                 if (r->printprocessor) {
6429                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6430                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6432                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6433                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6434                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
6435                         }
6436                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6439                 }
6440                 if (r->datatype) {
6441                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6442                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6443                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6444                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6445                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6446                                 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));
6447                         }
6448                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6449                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6451                 }
6452                 if (r->parameters) {
6453                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6454                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6455                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6456                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6457                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6458                                 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));
6459                         }
6460                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6461                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6463                 }
6464                 if (r->secdesc) {
6465                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6466                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6467                         {
6468                                 struct ndr_pull *_ndr_secdesc;
6469                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6470                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6471                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6472                         }
6473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6474                 }
6475         }
6476         return NDR_ERR_SUCCESS;
6477 }
6478
6479 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6480 {
6481         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6482         ndr->depth++;
6483         ndr_print_ptr(ndr, "servername", r->servername);
6484         ndr->depth++;
6485         if (r->servername) {
6486                 ndr_print_string(ndr, "servername", r->servername);
6487         }
6488         ndr->depth--;
6489         ndr_print_ptr(ndr, "printername", r->printername);
6490         ndr->depth++;
6491         if (r->printername) {
6492                 ndr_print_string(ndr, "printername", r->printername);
6493         }
6494         ndr->depth--;
6495         ndr_print_ptr(ndr, "sharename", r->sharename);
6496         ndr->depth++;
6497         if (r->sharename) {
6498                 ndr_print_string(ndr, "sharename", r->sharename);
6499         }
6500         ndr->depth--;
6501         ndr_print_ptr(ndr, "portname", r->portname);
6502         ndr->depth++;
6503         if (r->portname) {
6504                 ndr_print_string(ndr, "portname", r->portname);
6505         }
6506         ndr->depth--;
6507         ndr_print_ptr(ndr, "drivername", r->drivername);
6508         ndr->depth++;
6509         if (r->drivername) {
6510                 ndr_print_string(ndr, "drivername", r->drivername);
6511         }
6512         ndr->depth--;
6513         ndr_print_ptr(ndr, "comment", r->comment);
6514         ndr->depth++;
6515         if (r->comment) {
6516                 ndr_print_string(ndr, "comment", r->comment);
6517         }
6518         ndr->depth--;
6519         ndr_print_ptr(ndr, "location", r->location);
6520         ndr->depth++;
6521         if (r->location) {
6522                 ndr_print_string(ndr, "location", r->location);
6523         }
6524         ndr->depth--;
6525         ndr_print_ptr(ndr, "devmode", r->devmode);
6526         ndr->depth++;
6527         if (r->devmode) {
6528                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6529         }
6530         ndr->depth--;
6531         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6532         ndr->depth++;
6533         if (r->sepfile) {
6534                 ndr_print_string(ndr, "sepfile", r->sepfile);
6535         }
6536         ndr->depth--;
6537         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6538         ndr->depth++;
6539         if (r->printprocessor) {
6540                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6541         }
6542         ndr->depth--;
6543         ndr_print_ptr(ndr, "datatype", r->datatype);
6544         ndr->depth++;
6545         if (r->datatype) {
6546                 ndr_print_string(ndr, "datatype", r->datatype);
6547         }
6548         ndr->depth--;
6549         ndr_print_ptr(ndr, "parameters", r->parameters);
6550         ndr->depth++;
6551         if (r->parameters) {
6552                 ndr_print_string(ndr, "parameters", r->parameters);
6553         }
6554         ndr->depth--;
6555         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6556         ndr->depth++;
6557         if (r->secdesc) {
6558                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6559         }
6560         ndr->depth--;
6561         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6562         ndr_print_uint32(ndr, "priority", r->priority);
6563         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6564         ndr_print_uint32(ndr, "starttime", r->starttime);
6565         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6566         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6567         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6568         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6569         ndr->depth--;
6570 }
6571
6572 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6573 {
6574         if (ndr_flags & NDR_SCALARS) {
6575                 NDR_CHECK(ndr_push_align(ndr, 4));
6576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6577         }
6578         if (ndr_flags & NDR_BUFFERS) {
6579         }
6580         return NDR_ERR_SUCCESS;
6581 }
6582
6583 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6584 {
6585         if (ndr_flags & NDR_SCALARS) {
6586                 NDR_CHECK(ndr_pull_align(ndr, 4));
6587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6588         }
6589         if (ndr_flags & NDR_BUFFERS) {
6590         }
6591         return NDR_ERR_SUCCESS;
6592 }
6593
6594 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6595 {
6596         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6597         ndr->depth++;
6598         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6599         ndr->depth--;
6600 }
6601
6602 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6603 {
6604         if (ndr_flags & NDR_SCALARS) {
6605                 NDR_CHECK(ndr_push_align(ndr, 4));
6606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6608                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6609         }
6610         if (ndr_flags & NDR_BUFFERS) {
6611                 if (r->printername) {
6612                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6615                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6616                 }
6617                 if (r->servername) {
6618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6619                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6620                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6621                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6622                 }
6623         }
6624         return NDR_ERR_SUCCESS;
6625 }
6626
6627 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6628 {
6629         uint32_t _ptr_printername;
6630         TALLOC_CTX *_mem_save_printername_0;
6631         uint32_t _ptr_servername;
6632         TALLOC_CTX *_mem_save_servername_0;
6633         if (ndr_flags & NDR_SCALARS) {
6634                 NDR_CHECK(ndr_pull_align(ndr, 4));
6635                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6636                 if (_ptr_printername) {
6637                         NDR_PULL_ALLOC(ndr, r->printername);
6638                 } else {
6639                         r->printername = NULL;
6640                 }
6641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6642                 if (_ptr_servername) {
6643                         NDR_PULL_ALLOC(ndr, r->servername);
6644                 } else {
6645                         r->servername = NULL;
6646                 }
6647                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6648         }
6649         if (ndr_flags & NDR_BUFFERS) {
6650                 if (r->printername) {
6651                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6652                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6653                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6654                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6655                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6656                                 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));
6657                         }
6658                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6659                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6661                 }
6662                 if (r->servername) {
6663                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6664                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6666                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6667                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6668                                 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));
6669                         }
6670                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6671                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6673                 }
6674         }
6675         return NDR_ERR_SUCCESS;
6676 }
6677
6678 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6679 {
6680         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6681         ndr->depth++;
6682         ndr_print_ptr(ndr, "printername", r->printername);
6683         ndr->depth++;
6684         if (r->printername) {
6685                 ndr_print_string(ndr, "printername", r->printername);
6686         }
6687         ndr->depth--;
6688         ndr_print_ptr(ndr, "servername", r->servername);
6689         ndr->depth++;
6690         if (r->servername) {
6691                 ndr_print_string(ndr, "servername", r->servername);
6692         }
6693         ndr->depth--;
6694         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6695         ndr->depth--;
6696 }
6697
6698 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6699 {
6700         if (ndr_flags & NDR_SCALARS) {
6701                 NDR_CHECK(ndr_push_align(ndr, 4));
6702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6704                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6707         }
6708         if (ndr_flags & NDR_BUFFERS) {
6709                 if (r->printername) {
6710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6714                 }
6715                 if (r->portname) {
6716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6720                 }
6721         }
6722         return NDR_ERR_SUCCESS;
6723 }
6724
6725 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6726 {
6727         uint32_t _ptr_printername;
6728         TALLOC_CTX *_mem_save_printername_0;
6729         uint32_t _ptr_portname;
6730         TALLOC_CTX *_mem_save_portname_0;
6731         if (ndr_flags & NDR_SCALARS) {
6732                 NDR_CHECK(ndr_pull_align(ndr, 4));
6733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6734                 if (_ptr_printername) {
6735                         NDR_PULL_ALLOC(ndr, r->printername);
6736                 } else {
6737                         r->printername = NULL;
6738                 }
6739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6740                 if (_ptr_portname) {
6741                         NDR_PULL_ALLOC(ndr, r->portname);
6742                 } else {
6743                         r->portname = NULL;
6744                 }
6745                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6748         }
6749         if (ndr_flags & NDR_BUFFERS) {
6750                 if (r->printername) {
6751                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6752                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6755                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6756                                 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));
6757                         }
6758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6761                 }
6762                 if (r->portname) {
6763                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6764                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6767                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6768                                 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));
6769                         }
6770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6773                 }
6774         }
6775         return NDR_ERR_SUCCESS;
6776 }
6777
6778 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6779 {
6780         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6781         ndr->depth++;
6782         ndr_print_ptr(ndr, "printername", r->printername);
6783         ndr->depth++;
6784         if (r->printername) {
6785                 ndr_print_string(ndr, "printername", r->printername);
6786         }
6787         ndr->depth--;
6788         ndr_print_ptr(ndr, "portname", r->portname);
6789         ndr->depth++;
6790         if (r->portname) {
6791                 ndr_print_string(ndr, "portname", r->portname);
6792         }
6793         ndr->depth--;
6794         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6795         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6796         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6797         ndr->depth--;
6798 }
6799
6800 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6801 {
6802         if (ndr_flags & NDR_SCALARS) {
6803                 NDR_CHECK(ndr_push_align(ndr, 4));
6804                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6805         }
6806         if (ndr_flags & NDR_BUFFERS) {
6807         }
6808         return NDR_ERR_SUCCESS;
6809 }
6810
6811 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6812 {
6813         if (ndr_flags & NDR_SCALARS) {
6814                 NDR_CHECK(ndr_pull_align(ndr, 4));
6815                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6816         }
6817         if (ndr_flags & NDR_BUFFERS) {
6818         }
6819         return NDR_ERR_SUCCESS;
6820 }
6821
6822 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6823 {
6824         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6825         ndr->depth++;
6826         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6827         ndr->depth--;
6828 }
6829
6830 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6831 {
6832         if (ndr_flags & NDR_SCALARS) {
6833                 NDR_CHECK(ndr_push_align(ndr, 4));
6834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6835                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6836         }
6837         if (ndr_flags & NDR_BUFFERS) {
6838                 if (r->guid) {
6839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6843                 }
6844         }
6845         return NDR_ERR_SUCCESS;
6846 }
6847
6848 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6849 {
6850         uint32_t _ptr_guid;
6851         TALLOC_CTX *_mem_save_guid_0;
6852         if (ndr_flags & NDR_SCALARS) {
6853                 NDR_CHECK(ndr_pull_align(ndr, 4));
6854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6855                 if (_ptr_guid) {
6856                         NDR_PULL_ALLOC(ndr, r->guid);
6857                 } else {
6858                         r->guid = NULL;
6859                 }
6860                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6861         }
6862         if (ndr_flags & NDR_BUFFERS) {
6863                 if (r->guid) {
6864                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6865                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6868                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6869                                 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));
6870                         }
6871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6874                 }
6875         }
6876         return NDR_ERR_SUCCESS;
6877 }
6878
6879 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6880 {
6881         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6882         ndr->depth++;
6883         ndr_print_ptr(ndr, "guid", r->guid);
6884         ndr->depth++;
6885         if (r->guid) {
6886                 ndr_print_string(ndr, "guid", r->guid);
6887         }
6888         ndr->depth--;
6889         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6890         ndr->depth--;
6891 }
6892
6893 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6894 {
6895         if (ndr_flags & NDR_SCALARS) {
6896                 int level = ndr_push_get_switch_value(ndr, r);
6897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6898                 switch (level) {
6899                         case 0: {
6900                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6901                         break; }
6902
6903                         case 1: {
6904                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6905                         break; }
6906
6907                         case 2: {
6908                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6909                         break; }
6910
6911                         case 3: {
6912                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6913                         break; }
6914
6915                         case 4: {
6916                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6917                         break; }
6918
6919                         case 5: {
6920                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6921                         break; }
6922
6923                         case 6: {
6924                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6925                         break; }
6926
6927                         case 7: {
6928                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6929                         break; }
6930
6931                         case 8: {
6932                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6933                         break; }
6934
6935                         case 9: {
6936                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6937                         break; }
6938
6939                         default: {
6940                         break; }
6941
6942                 }
6943         }
6944         if (ndr_flags & NDR_BUFFERS) {
6945                 int level = ndr_push_get_switch_value(ndr, r);
6946                 switch (level) {
6947                         case 0:
6948                                 if (r->info0) {
6949                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6950                                 }
6951                         break;
6952
6953                         case 1:
6954                                 if (r->info1) {
6955                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6956                                 }
6957                         break;
6958
6959                         case 2:
6960                                 if (r->info2) {
6961                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6962                                 }
6963                         break;
6964
6965                         case 3:
6966                                 if (r->info3) {
6967                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6968                                 }
6969                         break;
6970
6971                         case 4:
6972                                 if (r->info4) {
6973                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6974                                 }
6975                         break;
6976
6977                         case 5:
6978                                 if (r->info5) {
6979                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6980                                 }
6981                         break;
6982
6983                         case 6:
6984                                 if (r->info6) {
6985                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6986                                 }
6987                         break;
6988
6989                         case 7:
6990                                 if (r->info7) {
6991                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6992                                 }
6993                         break;
6994
6995                         case 8:
6996                                 if (r->info8) {
6997                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6998                                 }
6999                         break;
7000
7001                         case 9:
7002                                 if (r->info9) {
7003                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7004                                 }
7005                         break;
7006
7007                         default:
7008                         break;
7009
7010                 }
7011         }
7012         return NDR_ERR_SUCCESS;
7013 }
7014
7015 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7016 {
7017         int level;
7018         uint32_t _level;
7019         TALLOC_CTX *_mem_save_info0_0;
7020         TALLOC_CTX *_mem_save_info1_0;
7021         TALLOC_CTX *_mem_save_info2_0;
7022         TALLOC_CTX *_mem_save_info3_0;
7023         TALLOC_CTX *_mem_save_info4_0;
7024         TALLOC_CTX *_mem_save_info5_0;
7025         TALLOC_CTX *_mem_save_info6_0;
7026         TALLOC_CTX *_mem_save_info7_0;
7027         TALLOC_CTX *_mem_save_info8_0;
7028         TALLOC_CTX *_mem_save_info9_0;
7029         level = ndr_pull_get_switch_value(ndr, r);
7030         if (ndr_flags & NDR_SCALARS) {
7031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7032                 if (_level != level) {
7033                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7034                 }
7035                 switch (level) {
7036                         case 0: {
7037                                 uint32_t _ptr_info0;
7038                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7039                                 if (_ptr_info0) {
7040                                         NDR_PULL_ALLOC(ndr, r->info0);
7041                                 } else {
7042                                         r->info0 = NULL;
7043                                 }
7044                         break; }
7045
7046                         case 1: {
7047                                 uint32_t _ptr_info1;
7048                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7049                                 if (_ptr_info1) {
7050                                         NDR_PULL_ALLOC(ndr, r->info1);
7051                                 } else {
7052                                         r->info1 = NULL;
7053                                 }
7054                         break; }
7055
7056                         case 2: {
7057                                 uint32_t _ptr_info2;
7058                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7059                                 if (_ptr_info2) {
7060                                         NDR_PULL_ALLOC(ndr, r->info2);
7061                                 } else {
7062                                         r->info2 = NULL;
7063                                 }
7064                         break; }
7065
7066                         case 3: {
7067                                 uint32_t _ptr_info3;
7068                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7069                                 if (_ptr_info3) {
7070                                         NDR_PULL_ALLOC(ndr, r->info3);
7071                                 } else {
7072                                         r->info3 = NULL;
7073                                 }
7074                         break; }
7075
7076                         case 4: {
7077                                 uint32_t _ptr_info4;
7078                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7079                                 if (_ptr_info4) {
7080                                         NDR_PULL_ALLOC(ndr, r->info4);
7081                                 } else {
7082                                         r->info4 = NULL;
7083                                 }
7084                         break; }
7085
7086                         case 5: {
7087                                 uint32_t _ptr_info5;
7088                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7089                                 if (_ptr_info5) {
7090                                         NDR_PULL_ALLOC(ndr, r->info5);
7091                                 } else {
7092                                         r->info5 = NULL;
7093                                 }
7094                         break; }
7095
7096                         case 6: {
7097                                 uint32_t _ptr_info6;
7098                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7099                                 if (_ptr_info6) {
7100                                         NDR_PULL_ALLOC(ndr, r->info6);
7101                                 } else {
7102                                         r->info6 = NULL;
7103                                 }
7104                         break; }
7105
7106                         case 7: {
7107                                 uint32_t _ptr_info7;
7108                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7109                                 if (_ptr_info7) {
7110                                         NDR_PULL_ALLOC(ndr, r->info7);
7111                                 } else {
7112                                         r->info7 = NULL;
7113                                 }
7114                         break; }
7115
7116                         case 8: {
7117                                 uint32_t _ptr_info8;
7118                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7119                                 if (_ptr_info8) {
7120                                         NDR_PULL_ALLOC(ndr, r->info8);
7121                                 } else {
7122                                         r->info8 = NULL;
7123                                 }
7124                         break; }
7125
7126                         case 9: {
7127                                 uint32_t _ptr_info9;
7128                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7129                                 if (_ptr_info9) {
7130                                         NDR_PULL_ALLOC(ndr, r->info9);
7131                                 } else {
7132                                         r->info9 = NULL;
7133                                 }
7134                         break; }
7135
7136                         default: {
7137                         break; }
7138
7139                 }
7140         }
7141         if (ndr_flags & NDR_BUFFERS) {
7142                 switch (level) {
7143                         case 0:
7144                                 if (r->info0) {
7145                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7146                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7147                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7148                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7149                                 }
7150                         break;
7151
7152                         case 1:
7153                                 if (r->info1) {
7154                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7155                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7156                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7157                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7158                                 }
7159                         break;
7160
7161                         case 2:
7162                                 if (r->info2) {
7163                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7164                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7165                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7166                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7167                                 }
7168                         break;
7169
7170                         case 3:
7171                                 if (r->info3) {
7172                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7173                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7174                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7175                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7176                                 }
7177                         break;
7178
7179                         case 4:
7180                                 if (r->info4) {
7181                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7182                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7183                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7184                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7185                                 }
7186                         break;
7187
7188                         case 5:
7189                                 if (r->info5) {
7190                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7191                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7192                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7193                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7194                                 }
7195                         break;
7196
7197                         case 6:
7198                                 if (r->info6) {
7199                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7200                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7201                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7202                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7203                                 }
7204                         break;
7205
7206                         case 7:
7207                                 if (r->info7) {
7208                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7209                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7210                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7211                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7212                                 }
7213                         break;
7214
7215                         case 8:
7216                                 if (r->info8) {
7217                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7218                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7219                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7220                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7221                                 }
7222                         break;
7223
7224                         case 9:
7225                                 if (r->info9) {
7226                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7227                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7228                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7229                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7230                                 }
7231                         break;
7232
7233                         default:
7234                         break;
7235
7236                 }
7237         }
7238         return NDR_ERR_SUCCESS;
7239 }
7240
7241 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7242 {
7243         int level;
7244         level = ndr_print_get_switch_value(ndr, r);
7245         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7246         switch (level) {
7247                 case 0:
7248                         ndr_print_ptr(ndr, "info0", r->info0);
7249                         ndr->depth++;
7250                         if (r->info0) {
7251                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7252                         }
7253                         ndr->depth--;
7254                 break;
7255
7256                 case 1:
7257                         ndr_print_ptr(ndr, "info1", r->info1);
7258                         ndr->depth++;
7259                         if (r->info1) {
7260                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7261                         }
7262                         ndr->depth--;
7263                 break;
7264
7265                 case 2:
7266                         ndr_print_ptr(ndr, "info2", r->info2);
7267                         ndr->depth++;
7268                         if (r->info2) {
7269                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7270                         }
7271                         ndr->depth--;
7272                 break;
7273
7274                 case 3:
7275                         ndr_print_ptr(ndr, "info3", r->info3);
7276                         ndr->depth++;
7277                         if (r->info3) {
7278                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7279                         }
7280                         ndr->depth--;
7281                 break;
7282
7283                 case 4:
7284                         ndr_print_ptr(ndr, "info4", r->info4);
7285                         ndr->depth++;
7286                         if (r->info4) {
7287                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7288                         }
7289                         ndr->depth--;
7290                 break;
7291
7292                 case 5:
7293                         ndr_print_ptr(ndr, "info5", r->info5);
7294                         ndr->depth++;
7295                         if (r->info5) {
7296                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7297                         }
7298                         ndr->depth--;
7299                 break;
7300
7301                 case 6:
7302                         ndr_print_ptr(ndr, "info6", r->info6);
7303                         ndr->depth++;
7304                         if (r->info6) {
7305                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7306                         }
7307                         ndr->depth--;
7308                 break;
7309
7310                 case 7:
7311                         ndr_print_ptr(ndr, "info7", r->info7);
7312                         ndr->depth++;
7313                         if (r->info7) {
7314                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7315                         }
7316                         ndr->depth--;
7317                 break;
7318
7319                 case 8:
7320                         ndr_print_ptr(ndr, "info8", r->info8);
7321                         ndr->depth++;
7322                         if (r->info8) {
7323                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7324                         }
7325                         ndr->depth--;
7326                 break;
7327
7328                 case 9:
7329                         ndr_print_ptr(ndr, "info9", r->info9);
7330                         ndr->depth++;
7331                         if (r->info9) {
7332                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7333                         }
7334                         ndr->depth--;
7335                 break;
7336
7337                 default:
7338                 break;
7339
7340         }
7341 }
7342
7343 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7344 {
7345         if (ndr_flags & NDR_SCALARS) {
7346                 NDR_CHECK(ndr_push_align(ndr, 4));
7347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7348                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7349                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7350         }
7351         if (ndr_flags & NDR_BUFFERS) {
7352                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7353         }
7354         return NDR_ERR_SUCCESS;
7355 }
7356
7357 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7358 {
7359         if (ndr_flags & NDR_SCALARS) {
7360                 NDR_CHECK(ndr_pull_align(ndr, 4));
7361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7362                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7363                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7364         }
7365         if (ndr_flags & NDR_BUFFERS) {
7366                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7367         }
7368         return NDR_ERR_SUCCESS;
7369 }
7370
7371 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7372 {
7373         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7374         ndr->depth++;
7375         ndr_print_uint32(ndr, "level", r->level);
7376         ndr_print_set_switch_value(ndr, &r->info, r->level);
7377         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7378         ndr->depth--;
7379 }
7380
7381 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7382 {
7383         if (ndr_flags & NDR_SCALARS) {
7384                 NDR_CHECK(ndr_push_align(ndr, 4));
7385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7386                 {
7387                         uint32_t _flags_save_string_array = ndr->flags;
7388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7389                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7390                         ndr->flags = _flags_save_string_array;
7391                 }
7392         }
7393         if (ndr_flags & NDR_BUFFERS) {
7394         }
7395         return NDR_ERR_SUCCESS;
7396 }
7397
7398 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7399 {
7400         if (ndr_flags & NDR_SCALARS) {
7401                 NDR_CHECK(ndr_pull_align(ndr, 4));
7402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7403                 {
7404                         uint32_t _flags_save_string_array = ndr->flags;
7405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7406                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7407                         ndr->flags = _flags_save_string_array;
7408                 }
7409         }
7410         if (ndr_flags & NDR_BUFFERS) {
7411         }
7412         return NDR_ERR_SUCCESS;
7413 }
7414
7415 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7416 {
7417         ndr_print_struct(ndr, name, "spoolss_StringArray");
7418         ndr->depth++;
7419         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);
7420         ndr_print_string_array(ndr, "string", r->string);
7421         ndr->depth--;
7422 }
7423
7424 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7425 {
7426         if (ndr_flags & NDR_SCALARS) {
7427                 NDR_CHECK(ndr_push_align(ndr, 4));
7428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7429         }
7430         if (ndr_flags & NDR_BUFFERS) {
7431                 if (r->driver_name) {
7432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7435                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7436                 }
7437         }
7438         return NDR_ERR_SUCCESS;
7439 }
7440
7441 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7442 {
7443         uint32_t _ptr_driver_name;
7444         TALLOC_CTX *_mem_save_driver_name_0;
7445         if (ndr_flags & NDR_SCALARS) {
7446                 NDR_CHECK(ndr_pull_align(ndr, 4));
7447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7448                 if (_ptr_driver_name) {
7449                         NDR_PULL_ALLOC(ndr, r->driver_name);
7450                 } else {
7451                         r->driver_name = NULL;
7452                 }
7453         }
7454         if (ndr_flags & NDR_BUFFERS) {
7455                 if (r->driver_name) {
7456                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7457                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7458                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7459                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7460                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7461                                 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));
7462                         }
7463                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7464                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7465                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7466                 }
7467         }
7468         return NDR_ERR_SUCCESS;
7469 }
7470
7471 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7472 {
7473         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7474         ndr->depth++;
7475         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7476         ndr->depth++;
7477         if (r->driver_name) {
7478                 ndr_print_string(ndr, "driver_name", r->driver_name);
7479         }
7480         ndr->depth--;
7481         ndr->depth--;
7482 }
7483
7484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7485 {
7486         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7487         return NDR_ERR_SUCCESS;
7488 }
7489
7490 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7491 {
7492         uint32_t v;
7493         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7494         *r = v;
7495         return NDR_ERR_SUCCESS;
7496 }
7497
7498 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7499 {
7500         const char *val = NULL;
7501
7502         switch (r) {
7503                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7504                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7505                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7506                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7507         }
7508         ndr_print_enum(ndr, name, "ENUM", val, r);
7509 }
7510
7511 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7512 {
7513         if (ndr_flags & NDR_SCALARS) {
7514                 NDR_CHECK(ndr_push_align(ndr, 4));
7515                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7521         }
7522         if (ndr_flags & NDR_BUFFERS) {
7523                 if (r->driver_name) {
7524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7528                 }
7529                 if (r->architecture) {
7530                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7533                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7534                 }
7535                 if (r->driver_path) {
7536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7540                 }
7541                 if (r->data_file) {
7542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7546                 }
7547                 if (r->config_file) {
7548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7551                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7552                 }
7553         }
7554         return NDR_ERR_SUCCESS;
7555 }
7556
7557 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7558 {
7559         uint32_t _ptr_driver_name;
7560         TALLOC_CTX *_mem_save_driver_name_0;
7561         uint32_t _ptr_architecture;
7562         TALLOC_CTX *_mem_save_architecture_0;
7563         uint32_t _ptr_driver_path;
7564         TALLOC_CTX *_mem_save_driver_path_0;
7565         uint32_t _ptr_data_file;
7566         TALLOC_CTX *_mem_save_data_file_0;
7567         uint32_t _ptr_config_file;
7568         TALLOC_CTX *_mem_save_config_file_0;
7569         if (ndr_flags & NDR_SCALARS) {
7570                 NDR_CHECK(ndr_pull_align(ndr, 4));
7571                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7573                 if (_ptr_driver_name) {
7574                         NDR_PULL_ALLOC(ndr, r->driver_name);
7575                 } else {
7576                         r->driver_name = NULL;
7577                 }
7578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7579                 if (_ptr_architecture) {
7580                         NDR_PULL_ALLOC(ndr, r->architecture);
7581                 } else {
7582                         r->architecture = NULL;
7583                 }
7584                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7585                 if (_ptr_driver_path) {
7586                         NDR_PULL_ALLOC(ndr, r->driver_path);
7587                 } else {
7588                         r->driver_path = NULL;
7589                 }
7590                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7591                 if (_ptr_data_file) {
7592                         NDR_PULL_ALLOC(ndr, r->data_file);
7593                 } else {
7594                         r->data_file = NULL;
7595                 }
7596                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7597                 if (_ptr_config_file) {
7598                         NDR_PULL_ALLOC(ndr, r->config_file);
7599                 } else {
7600                         r->config_file = NULL;
7601                 }
7602         }
7603         if (ndr_flags & NDR_BUFFERS) {
7604                 if (r->driver_name) {
7605                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7606                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7609                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7610                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7611                         }
7612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7615                 }
7616                 if (r->architecture) {
7617                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7618                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7621                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7622                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7623                         }
7624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7627                 }
7628                 if (r->driver_path) {
7629                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7630                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7631                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7632                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7633                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7634                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7635                         }
7636                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7637                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7639                 }
7640                 if (r->data_file) {
7641                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7642                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7644                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7645                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7646                                 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));
7647                         }
7648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7651                 }
7652                 if (r->config_file) {
7653                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7654                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7657                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7658                                 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));
7659                         }
7660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7661                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7663                 }
7664         }
7665         return NDR_ERR_SUCCESS;
7666 }
7667
7668 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7669 {
7670         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7671         ndr->depth++;
7672         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7673         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7674         ndr->depth++;
7675         if (r->driver_name) {
7676                 ndr_print_string(ndr, "driver_name", r->driver_name);
7677         }
7678         ndr->depth--;
7679         ndr_print_ptr(ndr, "architecture", r->architecture);
7680         ndr->depth++;
7681         if (r->architecture) {
7682                 ndr_print_string(ndr, "architecture", r->architecture);
7683         }
7684         ndr->depth--;
7685         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7686         ndr->depth++;
7687         if (r->driver_path) {
7688                 ndr_print_string(ndr, "driver_path", r->driver_path);
7689         }
7690         ndr->depth--;
7691         ndr_print_ptr(ndr, "data_file", r->data_file);
7692         ndr->depth++;
7693         if (r->data_file) {
7694                 ndr_print_string(ndr, "data_file", r->data_file);
7695         }
7696         ndr->depth--;
7697         ndr_print_ptr(ndr, "config_file", r->config_file);
7698         ndr->depth++;
7699         if (r->config_file) {
7700                 ndr_print_string(ndr, "config_file", r->config_file);
7701         }
7702         ndr->depth--;
7703         ndr->depth--;
7704 }
7705
7706 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7707 {
7708         if (ndr_flags & NDR_SCALARS) {
7709                 NDR_CHECK(ndr_push_align(ndr, 4));
7710                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7720                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7721         }
7722         if (ndr_flags & NDR_BUFFERS) {
7723                 if (r->driver_name) {
7724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7727                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7728                 }
7729                 if (r->architecture) {
7730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7734                 }
7735                 if (r->driver_path) {
7736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7740                 }
7741                 if (r->data_file) {
7742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7744                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7745                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7746                 }
7747                 if (r->config_file) {
7748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7750                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7751                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7752                 }
7753                 if (r->help_file) {
7754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7757                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7758                 }
7759                 if (r->monitor_name) {
7760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7761                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7764                 }
7765                 if (r->default_datatype) {
7766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7769                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7770                 }
7771                 if (r->dependent_files) {
7772                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7773                 }
7774         }
7775         return NDR_ERR_SUCCESS;
7776 }
7777
7778 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7779 {
7780         uint32_t _ptr_driver_name;
7781         TALLOC_CTX *_mem_save_driver_name_0;
7782         uint32_t _ptr_architecture;
7783         TALLOC_CTX *_mem_save_architecture_0;
7784         uint32_t _ptr_driver_path;
7785         TALLOC_CTX *_mem_save_driver_path_0;
7786         uint32_t _ptr_data_file;
7787         TALLOC_CTX *_mem_save_data_file_0;
7788         uint32_t _ptr_config_file;
7789         TALLOC_CTX *_mem_save_config_file_0;
7790         uint32_t _ptr_help_file;
7791         TALLOC_CTX *_mem_save_help_file_0;
7792         uint32_t _ptr_monitor_name;
7793         TALLOC_CTX *_mem_save_monitor_name_0;
7794         uint32_t _ptr_default_datatype;
7795         TALLOC_CTX *_mem_save_default_datatype_0;
7796         uint32_t _ptr_dependent_files;
7797         TALLOC_CTX *_mem_save_dependent_files_0;
7798         if (ndr_flags & NDR_SCALARS) {
7799                 NDR_CHECK(ndr_pull_align(ndr, 4));
7800                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7802                 if (_ptr_driver_name) {
7803                         NDR_PULL_ALLOC(ndr, r->driver_name);
7804                 } else {
7805                         r->driver_name = NULL;
7806                 }
7807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7808                 if (_ptr_architecture) {
7809                         NDR_PULL_ALLOC(ndr, r->architecture);
7810                 } else {
7811                         r->architecture = NULL;
7812                 }
7813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7814                 if (_ptr_driver_path) {
7815                         NDR_PULL_ALLOC(ndr, r->driver_path);
7816                 } else {
7817                         r->driver_path = NULL;
7818                 }
7819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7820                 if (_ptr_data_file) {
7821                         NDR_PULL_ALLOC(ndr, r->data_file);
7822                 } else {
7823                         r->data_file = NULL;
7824                 }
7825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7826                 if (_ptr_config_file) {
7827                         NDR_PULL_ALLOC(ndr, r->config_file);
7828                 } else {
7829                         r->config_file = NULL;
7830                 }
7831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7832                 if (_ptr_help_file) {
7833                         NDR_PULL_ALLOC(ndr, r->help_file);
7834                 } else {
7835                         r->help_file = NULL;
7836                 }
7837                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7838                 if (_ptr_monitor_name) {
7839                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7840                 } else {
7841                         r->monitor_name = NULL;
7842                 }
7843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7844                 if (_ptr_default_datatype) {
7845                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7846                 } else {
7847                         r->default_datatype = NULL;
7848                 }
7849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7851                 if (_ptr_dependent_files) {
7852                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7853                 } else {
7854                         r->dependent_files = NULL;
7855                 }
7856         }
7857         if (ndr_flags & NDR_BUFFERS) {
7858                 if (r->driver_name) {
7859                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7860                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7863                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7864                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7865                         }
7866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7869                 }
7870                 if (r->architecture) {
7871                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7872                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7875                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7876                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7877                         }
7878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7881                 }
7882                 if (r->driver_path) {
7883                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7884                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7887                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7888                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7889                         }
7890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7893                 }
7894                 if (r->data_file) {
7895                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7896                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7898                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7899                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7900                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7901                         }
7902                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7903                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7905                 }
7906                 if (r->config_file) {
7907                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7908                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7909                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7910                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7911                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7912                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7913                         }
7914                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7915                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7917                 }
7918                 if (r->help_file) {
7919                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7920                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7923                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7924                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
7925                         }
7926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7929                 }
7930                 if (r->monitor_name) {
7931                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7932                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7935                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7936                                 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));
7937                         }
7938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7941                 }
7942                 if (r->default_datatype) {
7943                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7944                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7947                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7948                                 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));
7949                         }
7950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7953                 }
7954                 if (r->dependent_files) {
7955                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7956                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7957                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7959                 }
7960         }
7961         return NDR_ERR_SUCCESS;
7962 }
7963
7964 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7965 {
7966         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7967         ndr->depth++;
7968         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7969         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7970         ndr->depth++;
7971         if (r->driver_name) {
7972                 ndr_print_string(ndr, "driver_name", r->driver_name);
7973         }
7974         ndr->depth--;
7975         ndr_print_ptr(ndr, "architecture", r->architecture);
7976         ndr->depth++;
7977         if (r->architecture) {
7978                 ndr_print_string(ndr, "architecture", r->architecture);
7979         }
7980         ndr->depth--;
7981         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7982         ndr->depth++;
7983         if (r->driver_path) {
7984                 ndr_print_string(ndr, "driver_path", r->driver_path);
7985         }
7986         ndr->depth--;
7987         ndr_print_ptr(ndr, "data_file", r->data_file);
7988         ndr->depth++;
7989         if (r->data_file) {
7990                 ndr_print_string(ndr, "data_file", r->data_file);
7991         }
7992         ndr->depth--;
7993         ndr_print_ptr(ndr, "config_file", r->config_file);
7994         ndr->depth++;
7995         if (r->config_file) {
7996                 ndr_print_string(ndr, "config_file", r->config_file);
7997         }
7998         ndr->depth--;
7999         ndr_print_ptr(ndr, "help_file", r->help_file);
8000         ndr->depth++;
8001         if (r->help_file) {
8002                 ndr_print_string(ndr, "help_file", r->help_file);
8003         }
8004         ndr->depth--;
8005         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8006         ndr->depth++;
8007         if (r->monitor_name) {
8008                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8009         }
8010         ndr->depth--;
8011         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8012         ndr->depth++;
8013         if (r->default_datatype) {
8014                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8015         }
8016         ndr->depth--;
8017         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);
8018         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8019         ndr->depth++;
8020         if (r->dependent_files) {
8021                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8022         }
8023         ndr->depth--;
8024         ndr->depth--;
8025 }
8026
8027 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8028 {
8029         if (ndr_flags & NDR_SCALARS) {
8030                 NDR_CHECK(ndr_push_align(ndr, 4));
8031                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8044         }
8045         if (ndr_flags & NDR_BUFFERS) {
8046                 if (r->driver_name) {
8047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8051                 }
8052                 if (r->architecture) {
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8057                 }
8058                 if (r->driver_path) {
8059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8063                 }
8064                 if (r->data_file) {
8065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8069                 }
8070                 if (r->config_file) {
8071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8075                 }
8076                 if (r->help_file) {
8077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8078                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8080                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8081                 }
8082                 if (r->monitor_name) {
8083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8086                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8087                 }
8088                 if (r->default_datatype) {
8089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8091                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8092                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8093                 }
8094                 if (r->dependent_files) {
8095                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8096                 }
8097                 if (r->previous_names) {
8098                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8099                 }
8100         }
8101         return NDR_ERR_SUCCESS;
8102 }
8103
8104 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8105 {
8106         uint32_t _ptr_driver_name;
8107         TALLOC_CTX *_mem_save_driver_name_0;
8108         uint32_t _ptr_architecture;
8109         TALLOC_CTX *_mem_save_architecture_0;
8110         uint32_t _ptr_driver_path;
8111         TALLOC_CTX *_mem_save_driver_path_0;
8112         uint32_t _ptr_data_file;
8113         TALLOC_CTX *_mem_save_data_file_0;
8114         uint32_t _ptr_config_file;
8115         TALLOC_CTX *_mem_save_config_file_0;
8116         uint32_t _ptr_help_file;
8117         TALLOC_CTX *_mem_save_help_file_0;
8118         uint32_t _ptr_monitor_name;
8119         TALLOC_CTX *_mem_save_monitor_name_0;
8120         uint32_t _ptr_default_datatype;
8121         TALLOC_CTX *_mem_save_default_datatype_0;
8122         uint32_t _ptr_dependent_files;
8123         TALLOC_CTX *_mem_save_dependent_files_0;
8124         uint32_t _ptr_previous_names;
8125         TALLOC_CTX *_mem_save_previous_names_0;
8126         if (ndr_flags & NDR_SCALARS) {
8127                 NDR_CHECK(ndr_pull_align(ndr, 4));
8128                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8130                 if (_ptr_driver_name) {
8131                         NDR_PULL_ALLOC(ndr, r->driver_name);
8132                 } else {
8133                         r->driver_name = NULL;
8134                 }
8135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8136                 if (_ptr_architecture) {
8137                         NDR_PULL_ALLOC(ndr, r->architecture);
8138                 } else {
8139                         r->architecture = NULL;
8140                 }
8141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8142                 if (_ptr_driver_path) {
8143                         NDR_PULL_ALLOC(ndr, r->driver_path);
8144                 } else {
8145                         r->driver_path = NULL;
8146                 }
8147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8148                 if (_ptr_data_file) {
8149                         NDR_PULL_ALLOC(ndr, r->data_file);
8150                 } else {
8151                         r->data_file = NULL;
8152                 }
8153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8154                 if (_ptr_config_file) {
8155                         NDR_PULL_ALLOC(ndr, r->config_file);
8156                 } else {
8157                         r->config_file = NULL;
8158                 }
8159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8160                 if (_ptr_help_file) {
8161                         NDR_PULL_ALLOC(ndr, r->help_file);
8162                 } else {
8163                         r->help_file = NULL;
8164                 }
8165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8166                 if (_ptr_monitor_name) {
8167                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8168                 } else {
8169                         r->monitor_name = NULL;
8170                 }
8171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8172                 if (_ptr_default_datatype) {
8173                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8174                 } else {
8175                         r->default_datatype = NULL;
8176                 }
8177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8179                 if (_ptr_dependent_files) {
8180                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8181                 } else {
8182                         r->dependent_files = NULL;
8183                 }
8184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8186                 if (_ptr_previous_names) {
8187                         NDR_PULL_ALLOC(ndr, r->previous_names);
8188                 } else {
8189                         r->previous_names = NULL;
8190                 }
8191         }
8192         if (ndr_flags & NDR_BUFFERS) {
8193                 if (r->driver_name) {
8194                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8195                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8198                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8200                         }
8201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8204                 }
8205                 if (r->architecture) {
8206                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8207                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8210                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8211                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8212                         }
8213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8216                 }
8217                 if (r->driver_path) {
8218                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8219                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8222                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8224                         }
8225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8228                 }
8229                 if (r->data_file) {
8230                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8231                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8234                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8236                         }
8237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8240                 }
8241                 if (r->config_file) {
8242                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8243                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8246                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8247                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8248                         }
8249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8252                 }
8253                 if (r->help_file) {
8254                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8255                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8258                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8259                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8260                         }
8261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8264                 }
8265                 if (r->monitor_name) {
8266                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8267                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8270                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8271                                 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));
8272                         }
8273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8276                 }
8277                 if (r->default_datatype) {
8278                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8279                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8282                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8283                                 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));
8284                         }
8285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8288                 }
8289                 if (r->dependent_files) {
8290                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8291                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8292                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8294                 }
8295                 if (r->previous_names) {
8296                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8297                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8298                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8300                 }
8301         }
8302         return NDR_ERR_SUCCESS;
8303 }
8304
8305 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8306 {
8307         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8308         ndr->depth++;
8309         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8310         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8311         ndr->depth++;
8312         if (r->driver_name) {
8313                 ndr_print_string(ndr, "driver_name", r->driver_name);
8314         }
8315         ndr->depth--;
8316         ndr_print_ptr(ndr, "architecture", r->architecture);
8317         ndr->depth++;
8318         if (r->architecture) {
8319                 ndr_print_string(ndr, "architecture", r->architecture);
8320         }
8321         ndr->depth--;
8322         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8323         ndr->depth++;
8324         if (r->driver_path) {
8325                 ndr_print_string(ndr, "driver_path", r->driver_path);
8326         }
8327         ndr->depth--;
8328         ndr_print_ptr(ndr, "data_file", r->data_file);
8329         ndr->depth++;
8330         if (r->data_file) {
8331                 ndr_print_string(ndr, "data_file", r->data_file);
8332         }
8333         ndr->depth--;
8334         ndr_print_ptr(ndr, "config_file", r->config_file);
8335         ndr->depth++;
8336         if (r->config_file) {
8337                 ndr_print_string(ndr, "config_file", r->config_file);
8338         }
8339         ndr->depth--;
8340         ndr_print_ptr(ndr, "help_file", r->help_file);
8341         ndr->depth++;
8342         if (r->help_file) {
8343                 ndr_print_string(ndr, "help_file", r->help_file);
8344         }
8345         ndr->depth--;
8346         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8347         ndr->depth++;
8348         if (r->monitor_name) {
8349                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8350         }
8351         ndr->depth--;
8352         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8353         ndr->depth++;
8354         if (r->default_datatype) {
8355                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8356         }
8357         ndr->depth--;
8358         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);
8359         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8360         ndr->depth++;
8361         if (r->dependent_files) {
8362                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8363         }
8364         ndr->depth--;
8365         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);
8366         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8367         ndr->depth++;
8368         if (r->previous_names) {
8369                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8370         }
8371         ndr->depth--;
8372         ndr->depth--;
8373 }
8374
8375 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8376 {
8377         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8378         return NDR_ERR_SUCCESS;
8379 }
8380
8381 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8382 {
8383         uint32_t v;
8384         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8385         *r = v;
8386         return NDR_ERR_SUCCESS;
8387 }
8388
8389 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
8390 {
8391         ndr_print_uint32(ndr, name, r);
8392         ndr->depth++;
8393         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
8394         ndr->depth--;
8395 }
8396
8397 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8398 {
8399         if (ndr_flags & NDR_SCALARS) {
8400                 NDR_CHECK(ndr_push_align(ndr, 8));
8401                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8406                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8414                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8415                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8417                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8420         }
8421         if (ndr_flags & NDR_BUFFERS) {
8422                 if (r->driver_name) {
8423                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8426                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8427                 }
8428                 if (r->architecture) {
8429                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8432                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8433                 }
8434                 if (r->driver_path) {
8435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8438                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8439                 }
8440                 if (r->data_file) {
8441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8445                 }
8446                 if (r->config_file) {
8447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8450                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8451                 }
8452                 if (r->help_file) {
8453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8456                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8457                 }
8458                 if (r->monitor_name) {
8459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8462                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8463                 }
8464                 if (r->default_datatype) {
8465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8468                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8469                 }
8470                 if (r->dependent_files) {
8471                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8472                 }
8473                 if (r->previous_names) {
8474                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8475                 }
8476                 if (r->manufacturer_name) {
8477                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8478                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8479                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8480                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8481                 }
8482                 if (r->manufacturer_url) {
8483                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8484                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8485                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8486                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8487                 }
8488                 if (r->hardware_id) {
8489                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8490                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8491                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8492                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8493                 }
8494                 if (r->provider) {
8495                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8496                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8497                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8498                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8499                 }
8500         }
8501         return NDR_ERR_SUCCESS;
8502 }
8503
8504 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8505 {
8506         uint32_t _ptr_driver_name;
8507         TALLOC_CTX *_mem_save_driver_name_0;
8508         uint32_t _ptr_architecture;
8509         TALLOC_CTX *_mem_save_architecture_0;
8510         uint32_t _ptr_driver_path;
8511         TALLOC_CTX *_mem_save_driver_path_0;
8512         uint32_t _ptr_data_file;
8513         TALLOC_CTX *_mem_save_data_file_0;
8514         uint32_t _ptr_config_file;
8515         TALLOC_CTX *_mem_save_config_file_0;
8516         uint32_t _ptr_help_file;
8517         TALLOC_CTX *_mem_save_help_file_0;
8518         uint32_t _ptr_monitor_name;
8519         TALLOC_CTX *_mem_save_monitor_name_0;
8520         uint32_t _ptr_default_datatype;
8521         TALLOC_CTX *_mem_save_default_datatype_0;
8522         uint32_t _ptr_dependent_files;
8523         TALLOC_CTX *_mem_save_dependent_files_0;
8524         uint32_t _ptr_previous_names;
8525         TALLOC_CTX *_mem_save_previous_names_0;
8526         uint32_t _ptr_manufacturer_name;
8527         TALLOC_CTX *_mem_save_manufacturer_name_0;
8528         uint32_t _ptr_manufacturer_url;
8529         TALLOC_CTX *_mem_save_manufacturer_url_0;
8530         uint32_t _ptr_hardware_id;
8531         TALLOC_CTX *_mem_save_hardware_id_0;
8532         uint32_t _ptr_provider;
8533         TALLOC_CTX *_mem_save_provider_0;
8534         if (ndr_flags & NDR_SCALARS) {
8535                 NDR_CHECK(ndr_pull_align(ndr, 8));
8536                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8538                 if (_ptr_driver_name) {
8539                         NDR_PULL_ALLOC(ndr, r->driver_name);
8540                 } else {
8541                         r->driver_name = NULL;
8542                 }
8543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8544                 if (_ptr_architecture) {
8545                         NDR_PULL_ALLOC(ndr, r->architecture);
8546                 } else {
8547                         r->architecture = NULL;
8548                 }
8549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8550                 if (_ptr_driver_path) {
8551                         NDR_PULL_ALLOC(ndr, r->driver_path);
8552                 } else {
8553                         r->driver_path = NULL;
8554                 }
8555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8556                 if (_ptr_data_file) {
8557                         NDR_PULL_ALLOC(ndr, r->data_file);
8558                 } else {
8559                         r->data_file = NULL;
8560                 }
8561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8562                 if (_ptr_config_file) {
8563                         NDR_PULL_ALLOC(ndr, r->config_file);
8564                 } else {
8565                         r->config_file = NULL;
8566                 }
8567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8568                 if (_ptr_help_file) {
8569                         NDR_PULL_ALLOC(ndr, r->help_file);
8570                 } else {
8571                         r->help_file = NULL;
8572                 }
8573                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8574                 if (_ptr_monitor_name) {
8575                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8576                 } else {
8577                         r->monitor_name = NULL;
8578                 }
8579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8580                 if (_ptr_default_datatype) {
8581                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8582                 } else {
8583                         r->default_datatype = NULL;
8584                 }
8585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8586                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8587                 if (_ptr_dependent_files) {
8588                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8589                 } else {
8590                         r->dependent_files = NULL;
8591                 }
8592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8594                 if (_ptr_previous_names) {
8595                         NDR_PULL_ALLOC(ndr, r->previous_names);
8596                 } else {
8597                         r->previous_names = NULL;
8598                 }
8599                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8600                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8602                 if (_ptr_manufacturer_name) {
8603                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8604                 } else {
8605                         r->manufacturer_name = NULL;
8606                 }
8607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8608                 if (_ptr_manufacturer_url) {
8609                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8610                 } else {
8611                         r->manufacturer_url = NULL;
8612                 }
8613                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8614                 if (_ptr_hardware_id) {
8615                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8616                 } else {
8617                         r->hardware_id = NULL;
8618                 }
8619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8620                 if (_ptr_provider) {
8621                         NDR_PULL_ALLOC(ndr, r->provider);
8622                 } else {
8623                         r->provider = NULL;
8624                 }
8625         }
8626         if (ndr_flags & NDR_BUFFERS) {
8627                 if (r->driver_name) {
8628                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8629                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8632                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8633                                 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));
8634                         }
8635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8636                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8638                 }
8639                 if (r->architecture) {
8640                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8641                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8644                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8645                                 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));
8646                         }
8647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8650                 }
8651                 if (r->driver_path) {
8652                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8653                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8656                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8657                                 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));
8658                         }
8659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8660                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8662                 }
8663                 if (r->data_file) {
8664                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8665                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8668                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8669                                 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));
8670                         }
8671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8674                 }
8675                 if (r->config_file) {
8676                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8677                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8680                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8681                                 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));
8682                         }
8683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8686                 }
8687                 if (r->help_file) {
8688                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8689                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8692                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8693                                 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));
8694                         }
8695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8698                 }
8699                 if (r->monitor_name) {
8700                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8701                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8702                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8703                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8704                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8705                                 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));
8706                         }
8707                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8708                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8709                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8710                 }
8711                 if (r->default_datatype) {
8712                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8713                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8714                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8715                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8716                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8717                                 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));
8718                         }
8719                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8720                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8722                 }
8723                 if (r->dependent_files) {
8724                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8725                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8726                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8728                 }
8729                 if (r->previous_names) {
8730                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8731                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8732                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8734                 }
8735                 if (r->manufacturer_name) {
8736                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8737                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8738                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8739                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8740                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8741                                 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));
8742                         }
8743                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8744                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8745                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8746                 }
8747                 if (r->manufacturer_url) {
8748                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8749                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8750                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8751                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8752                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8753                                 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));
8754                         }
8755                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8756                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8758                 }
8759                 if (r->hardware_id) {
8760                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8761                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8763                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8764                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8765                                 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));
8766                         }
8767                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8768                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8770                 }
8771                 if (r->provider) {
8772                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8773                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8774                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8775                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8776                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8777                                 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));
8778                         }
8779                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8780                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8782                 }
8783         }
8784         return NDR_ERR_SUCCESS;
8785 }
8786
8787 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8788 {
8789         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8790         ndr->depth++;
8791         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8792         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8793         ndr->depth++;
8794         if (r->driver_name) {
8795                 ndr_print_string(ndr, "driver_name", r->driver_name);
8796         }
8797         ndr->depth--;
8798         ndr_print_ptr(ndr, "architecture", r->architecture);
8799         ndr->depth++;
8800         if (r->architecture) {
8801                 ndr_print_string(ndr, "architecture", r->architecture);
8802         }
8803         ndr->depth--;
8804         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8805         ndr->depth++;
8806         if (r->driver_path) {
8807                 ndr_print_string(ndr, "driver_path", r->driver_path);
8808         }
8809         ndr->depth--;
8810         ndr_print_ptr(ndr, "data_file", r->data_file);
8811         ndr->depth++;
8812         if (r->data_file) {
8813                 ndr_print_string(ndr, "data_file", r->data_file);
8814         }
8815         ndr->depth--;
8816         ndr_print_ptr(ndr, "config_file", r->config_file);
8817         ndr->depth++;
8818         if (r->config_file) {
8819                 ndr_print_string(ndr, "config_file", r->config_file);
8820         }
8821         ndr->depth--;
8822         ndr_print_ptr(ndr, "help_file", r->help_file);
8823         ndr->depth++;
8824         if (r->help_file) {
8825                 ndr_print_string(ndr, "help_file", r->help_file);
8826         }
8827         ndr->depth--;
8828         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8829         ndr->depth++;
8830         if (r->monitor_name) {
8831                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8832         }
8833         ndr->depth--;
8834         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8835         ndr->depth++;
8836         if (r->default_datatype) {
8837                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8838         }
8839         ndr->depth--;
8840         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);
8841         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8842         ndr->depth++;
8843         if (r->dependent_files) {
8844                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8845         }
8846         ndr->depth--;
8847         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);
8848         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8849         ndr->depth++;
8850         if (r->previous_names) {
8851                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8852         }
8853         ndr->depth--;
8854         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8855         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8856         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8857         ndr->depth++;
8858         if (r->manufacturer_name) {
8859                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8860         }
8861         ndr->depth--;
8862         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8863         ndr->depth++;
8864         if (r->manufacturer_url) {
8865                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8866         }
8867         ndr->depth--;
8868         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8869         ndr->depth++;
8870         if (r->hardware_id) {
8871                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8872         }
8873         ndr->depth--;
8874         ndr_print_ptr(ndr, "provider", r->provider);
8875         ndr->depth++;
8876         if (r->provider) {
8877                 ndr_print_string(ndr, "provider", r->provider);
8878         }
8879         ndr->depth--;
8880         ndr->depth--;
8881 }
8882
8883 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8884 {
8885         if (ndr_flags & NDR_SCALARS) {
8886                 NDR_CHECK(ndr_push_align(ndr, 8));
8887                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8890                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8900                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8901                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8914                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8915                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8916         }
8917         if (ndr_flags & NDR_BUFFERS) {
8918                 if (r->driver_name) {
8919                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8920                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8922                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8923                 }
8924                 if (r->architecture) {
8925                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8926                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8928                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8929                 }
8930                 if (r->driver_path) {
8931                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8932                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8934                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8935                 }
8936                 if (r->data_file) {
8937                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8938                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8940                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8941                 }
8942                 if (r->config_file) {
8943                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8944                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8946                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8947                 }
8948                 if (r->help_file) {
8949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8950                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8951                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8952                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8953                 }
8954                 if (r->monitor_name) {
8955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8958                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8959                 }
8960                 if (r->default_datatype) {
8961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8963                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8964                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8965                 }
8966                 if (r->dependent_files) {
8967                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8968                 }
8969                 if (r->previous_names) {
8970                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8971                 }
8972                 if (r->manufacturer_name) {
8973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8976                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8977                 }
8978                 if (r->manufacturer_url) {
8979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8982                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8983                 }
8984                 if (r->hardware_id) {
8985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8987                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8988                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8989                 }
8990                 if (r->provider) {
8991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8994                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8995                 }
8996                 if (r->print_processor) {
8997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9000                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9001                 }
9002                 if (r->vendor_setup) {
9003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9006                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9007                 }
9008                 if (r->color_profiles) {
9009                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9010                 }
9011                 if (r->inf_path) {
9012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9015                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9016                 }
9017                 if (r->core_driver_dependencies) {
9018                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9019                 }
9020         }
9021         return NDR_ERR_SUCCESS;
9022 }
9023
9024 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9025 {
9026         uint32_t _ptr_driver_name;
9027         TALLOC_CTX *_mem_save_driver_name_0;
9028         uint32_t _ptr_architecture;
9029         TALLOC_CTX *_mem_save_architecture_0;
9030         uint32_t _ptr_driver_path;
9031         TALLOC_CTX *_mem_save_driver_path_0;
9032         uint32_t _ptr_data_file;
9033         TALLOC_CTX *_mem_save_data_file_0;
9034         uint32_t _ptr_config_file;
9035         TALLOC_CTX *_mem_save_config_file_0;
9036         uint32_t _ptr_help_file;
9037         TALLOC_CTX *_mem_save_help_file_0;
9038         uint32_t _ptr_monitor_name;
9039         TALLOC_CTX *_mem_save_monitor_name_0;
9040         uint32_t _ptr_default_datatype;
9041         TALLOC_CTX *_mem_save_default_datatype_0;
9042         uint32_t _ptr_dependent_files;
9043         TALLOC_CTX *_mem_save_dependent_files_0;
9044         uint32_t _ptr_previous_names;
9045         TALLOC_CTX *_mem_save_previous_names_0;
9046         uint32_t _ptr_manufacturer_name;
9047         TALLOC_CTX *_mem_save_manufacturer_name_0;
9048         uint32_t _ptr_manufacturer_url;
9049         TALLOC_CTX *_mem_save_manufacturer_url_0;
9050         uint32_t _ptr_hardware_id;
9051         TALLOC_CTX *_mem_save_hardware_id_0;
9052         uint32_t _ptr_provider;
9053         TALLOC_CTX *_mem_save_provider_0;
9054         uint32_t _ptr_print_processor;
9055         TALLOC_CTX *_mem_save_print_processor_0;
9056         uint32_t _ptr_vendor_setup;
9057         TALLOC_CTX *_mem_save_vendor_setup_0;
9058         uint32_t _ptr_color_profiles;
9059         TALLOC_CTX *_mem_save_color_profiles_0;
9060         uint32_t _ptr_inf_path;
9061         TALLOC_CTX *_mem_save_inf_path_0;
9062         uint32_t _ptr_core_driver_dependencies;
9063         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9064         if (ndr_flags & NDR_SCALARS) {
9065                 NDR_CHECK(ndr_pull_align(ndr, 8));
9066                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9068                 if (_ptr_driver_name) {
9069                         NDR_PULL_ALLOC(ndr, r->driver_name);
9070                 } else {
9071                         r->driver_name = NULL;
9072                 }
9073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9074                 if (_ptr_architecture) {
9075                         NDR_PULL_ALLOC(ndr, r->architecture);
9076                 } else {
9077                         r->architecture = NULL;
9078                 }
9079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9080                 if (_ptr_driver_path) {
9081                         NDR_PULL_ALLOC(ndr, r->driver_path);
9082                 } else {
9083                         r->driver_path = NULL;
9084                 }
9085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9086                 if (_ptr_data_file) {
9087                         NDR_PULL_ALLOC(ndr, r->data_file);
9088                 } else {
9089                         r->data_file = NULL;
9090                 }
9091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9092                 if (_ptr_config_file) {
9093                         NDR_PULL_ALLOC(ndr, r->config_file);
9094                 } else {
9095                         r->config_file = NULL;
9096                 }
9097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9098                 if (_ptr_help_file) {
9099                         NDR_PULL_ALLOC(ndr, r->help_file);
9100                 } else {
9101                         r->help_file = NULL;
9102                 }
9103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9104                 if (_ptr_monitor_name) {
9105                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9106                 } else {
9107                         r->monitor_name = NULL;
9108                 }
9109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9110                 if (_ptr_default_datatype) {
9111                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9112                 } else {
9113                         r->default_datatype = NULL;
9114                 }
9115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9117                 if (_ptr_dependent_files) {
9118                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9119                 } else {
9120                         r->dependent_files = NULL;
9121                 }
9122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9124                 if (_ptr_previous_names) {
9125                         NDR_PULL_ALLOC(ndr, r->previous_names);
9126                 } else {
9127                         r->previous_names = NULL;
9128                 }
9129                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9130                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9131                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9132                 if (_ptr_manufacturer_name) {
9133                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9134                 } else {
9135                         r->manufacturer_name = NULL;
9136                 }
9137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9138                 if (_ptr_manufacturer_url) {
9139                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9140                 } else {
9141                         r->manufacturer_url = NULL;
9142                 }
9143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9144                 if (_ptr_hardware_id) {
9145                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9146                 } else {
9147                         r->hardware_id = NULL;
9148                 }
9149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9150                 if (_ptr_provider) {
9151                         NDR_PULL_ALLOC(ndr, r->provider);
9152                 } else {
9153                         r->provider = NULL;
9154                 }
9155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9156                 if (_ptr_print_processor) {
9157                         NDR_PULL_ALLOC(ndr, r->print_processor);
9158                 } else {
9159                         r->print_processor = NULL;
9160                 }
9161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9162                 if (_ptr_vendor_setup) {
9163                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9164                 } else {
9165                         r->vendor_setup = NULL;
9166                 }
9167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9169                 if (_ptr_color_profiles) {
9170                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9171                 } else {
9172                         r->color_profiles = NULL;
9173                 }
9174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9175                 if (_ptr_inf_path) {
9176                         NDR_PULL_ALLOC(ndr, r->inf_path);
9177                 } else {
9178                         r->inf_path = NULL;
9179                 }
9180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9183                 if (_ptr_core_driver_dependencies) {
9184                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9185                 } else {
9186                         r->core_driver_dependencies = NULL;
9187                 }
9188                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9189                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9190         }
9191         if (ndr_flags & NDR_BUFFERS) {
9192                 if (r->driver_name) {
9193                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9194                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9195                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9196                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9197                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9198                                 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));
9199                         }
9200                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9201                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9203                 }
9204                 if (r->architecture) {
9205                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9206                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9207                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9208                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9209                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9210                                 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));
9211                         }
9212                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9213                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9215                 }
9216                 if (r->driver_path) {
9217                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9218                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9219                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9220                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9221                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9222                                 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));
9223                         }
9224                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9225                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9227                 }
9228                 if (r->data_file) {
9229                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9230                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9231                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9232                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9233                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9234                                 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));
9235                         }
9236                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9237                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9239                 }
9240                 if (r->config_file) {
9241                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9242                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9243                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9244                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9245                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9246                                 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));
9247                         }
9248                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9249                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9251                 }
9252                 if (r->help_file) {
9253                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9254                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9255                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9256                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9257                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9258                                 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));
9259                         }
9260                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9261                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9263                 }
9264                 if (r->monitor_name) {
9265                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9266                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9267                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9268                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9269                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9270                                 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));
9271                         }
9272                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9275                 }
9276                 if (r->default_datatype) {
9277                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9278                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9280                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9281                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9282                                 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));
9283                         }
9284                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9285                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9287                 }
9288                 if (r->dependent_files) {
9289                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9290                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9291                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9293                 }
9294                 if (r->previous_names) {
9295                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9296                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9297                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9299                 }
9300                 if (r->manufacturer_name) {
9301                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9302                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9303                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9304                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9305                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9306                                 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));
9307                         }
9308                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9309                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9311                 }
9312                 if (r->manufacturer_url) {
9313                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9314                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9317                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9318                                 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));
9319                         }
9320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9323                 }
9324                 if (r->hardware_id) {
9325                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9326                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9329                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9330                                 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));
9331                         }
9332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9333                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9335                 }
9336                 if (r->provider) {
9337                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9338                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9339                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9340                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9341                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9342                                 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));
9343                         }
9344                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9345                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9347                 }
9348                 if (r->print_processor) {
9349                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9350                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9353                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9354                                 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));
9355                         }
9356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9357                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9359                 }
9360                 if (r->vendor_setup) {
9361                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9362                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9363                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9364                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9365                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9366                                 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));
9367                         }
9368                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9369                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9371                 }
9372                 if (r->color_profiles) {
9373                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9374                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9375                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9376                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9377                 }
9378                 if (r->inf_path) {
9379                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9380                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9381                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9382                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9383                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9384                                 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));
9385                         }
9386                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9387                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9388                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9389                 }
9390                 if (r->core_driver_dependencies) {
9391                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9392                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9393                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9394                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9395                 }
9396         }
9397         return NDR_ERR_SUCCESS;
9398 }
9399
9400 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9401 {
9402         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9403         ndr->depth++;
9404         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9405         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9406         ndr->depth++;
9407         if (r->driver_name) {
9408                 ndr_print_string(ndr, "driver_name", r->driver_name);
9409         }
9410         ndr->depth--;
9411         ndr_print_ptr(ndr, "architecture", r->architecture);
9412         ndr->depth++;
9413         if (r->architecture) {
9414                 ndr_print_string(ndr, "architecture", r->architecture);
9415         }
9416         ndr->depth--;
9417         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9418         ndr->depth++;
9419         if (r->driver_path) {
9420                 ndr_print_string(ndr, "driver_path", r->driver_path);
9421         }
9422         ndr->depth--;
9423         ndr_print_ptr(ndr, "data_file", r->data_file);
9424         ndr->depth++;
9425         if (r->data_file) {
9426                 ndr_print_string(ndr, "data_file", r->data_file);
9427         }
9428         ndr->depth--;
9429         ndr_print_ptr(ndr, "config_file", r->config_file);
9430         ndr->depth++;
9431         if (r->config_file) {
9432                 ndr_print_string(ndr, "config_file", r->config_file);
9433         }
9434         ndr->depth--;
9435         ndr_print_ptr(ndr, "help_file", r->help_file);
9436         ndr->depth++;
9437         if (r->help_file) {
9438                 ndr_print_string(ndr, "help_file", r->help_file);
9439         }
9440         ndr->depth--;
9441         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9442         ndr->depth++;
9443         if (r->monitor_name) {
9444                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9445         }
9446         ndr->depth--;
9447         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9448         ndr->depth++;
9449         if (r->default_datatype) {
9450                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9451         }
9452         ndr->depth--;
9453         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);
9454         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9455         ndr->depth++;
9456         if (r->dependent_files) {
9457                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9458         }
9459         ndr->depth--;
9460         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);
9461         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9462         ndr->depth++;
9463         if (r->previous_names) {
9464                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9465         }
9466         ndr->depth--;
9467         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9468         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9469         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9470         ndr->depth++;
9471         if (r->manufacturer_name) {
9472                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9473         }
9474         ndr->depth--;
9475         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9476         ndr->depth++;
9477         if (r->manufacturer_url) {
9478                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9479         }
9480         ndr->depth--;
9481         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9482         ndr->depth++;
9483         if (r->hardware_id) {
9484                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9485         }
9486         ndr->depth--;
9487         ndr_print_ptr(ndr, "provider", r->provider);
9488         ndr->depth++;
9489         if (r->provider) {
9490                 ndr_print_string(ndr, "provider", r->provider);
9491         }
9492         ndr->depth--;
9493         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9494         ndr->depth++;
9495         if (r->print_processor) {
9496                 ndr_print_string(ndr, "print_processor", r->print_processor);
9497         }
9498         ndr->depth--;
9499         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9500         ndr->depth++;
9501         if (r->vendor_setup) {
9502                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9503         }
9504         ndr->depth--;
9505         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);
9506         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9507         ndr->depth++;
9508         if (r->color_profiles) {
9509                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9510         }
9511         ndr->depth--;
9512         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9513         ndr->depth++;
9514         if (r->inf_path) {
9515                 ndr_print_string(ndr, "inf_path", r->inf_path);
9516         }
9517         ndr->depth--;
9518         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9519         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);
9520         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9521         ndr->depth++;
9522         if (r->core_driver_dependencies) {
9523                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9524         }
9525         ndr->depth--;
9526         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9527         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9528         ndr->depth--;
9529 }
9530
9531 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9532 {
9533         if (ndr_flags & NDR_SCALARS) {
9534                 int level = ndr_push_get_switch_value(ndr, r);
9535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9536                 switch (level) {
9537                         case 1: {
9538                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9539                         break; }
9540
9541                         case 2: {
9542                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9543                         break; }
9544
9545                         case 3: {
9546                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9547                         break; }
9548
9549                         case 4: {
9550                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9551                         break; }
9552
9553                         case 6: {
9554                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9555                         break; }
9556
9557                         case 8: {
9558                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9559                         break; }
9560
9561                         default:
9562                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9563                 }
9564         }
9565         if (ndr_flags & NDR_BUFFERS) {
9566                 int level = ndr_push_get_switch_value(ndr, r);
9567                 switch (level) {
9568                         case 1:
9569                                 if (r->info1) {
9570                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9571                                 }
9572                         break;
9573
9574                         case 2:
9575                                 if (r->info2) {
9576                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9577                                 }
9578                         break;
9579
9580                         case 3:
9581                                 if (r->info3) {
9582                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9583                                 }
9584                         break;
9585
9586                         case 4:
9587                                 if (r->info4) {
9588                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9589                                 }
9590                         break;
9591
9592                         case 6:
9593                                 if (r->info6) {
9594                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9595                                 }
9596                         break;
9597
9598                         case 8:
9599                                 if (r->info8) {
9600                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9601                                 }
9602                         break;
9603
9604                         default:
9605                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9606                 }
9607         }
9608         return NDR_ERR_SUCCESS;
9609 }
9610
9611 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9612 {
9613         int level;
9614         uint32_t _level;
9615         TALLOC_CTX *_mem_save_info1_0;
9616         TALLOC_CTX *_mem_save_info2_0;
9617         TALLOC_CTX *_mem_save_info3_0;
9618         TALLOC_CTX *_mem_save_info4_0;
9619         TALLOC_CTX *_mem_save_info6_0;
9620         TALLOC_CTX *_mem_save_info8_0;
9621         level = ndr_pull_get_switch_value(ndr, r);
9622         if (ndr_flags & NDR_SCALARS) {
9623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9624                 if (_level != level) {
9625                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9626                 }
9627                 switch (level) {
9628                         case 1: {
9629                                 uint32_t _ptr_info1;
9630                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9631                                 if (_ptr_info1) {
9632                                         NDR_PULL_ALLOC(ndr, r->info1);
9633                                 } else {
9634                                         r->info1 = NULL;
9635                                 }
9636                         break; }
9637
9638                         case 2: {
9639                                 uint32_t _ptr_info2;
9640                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9641                                 if (_ptr_info2) {
9642                                         NDR_PULL_ALLOC(ndr, r->info2);
9643                                 } else {
9644                                         r->info2 = NULL;
9645                                 }
9646                         break; }
9647
9648                         case 3: {
9649                                 uint32_t _ptr_info3;
9650                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9651                                 if (_ptr_info3) {
9652                                         NDR_PULL_ALLOC(ndr, r->info3);
9653                                 } else {
9654                                         r->info3 = NULL;
9655                                 }
9656                         break; }
9657
9658                         case 4: {
9659                                 uint32_t _ptr_info4;
9660                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9661                                 if (_ptr_info4) {
9662                                         NDR_PULL_ALLOC(ndr, r->info4);
9663                                 } else {
9664                                         r->info4 = NULL;
9665                                 }
9666                         break; }
9667
9668                         case 6: {
9669                                 uint32_t _ptr_info6;
9670                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9671                                 if (_ptr_info6) {
9672                                         NDR_PULL_ALLOC(ndr, r->info6);
9673                                 } else {
9674                                         r->info6 = NULL;
9675                                 }
9676                         break; }
9677
9678                         case 8: {
9679                                 uint32_t _ptr_info8;
9680                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9681                                 if (_ptr_info8) {
9682                                         NDR_PULL_ALLOC(ndr, r->info8);
9683                                 } else {
9684                                         r->info8 = NULL;
9685                                 }
9686                         break; }
9687
9688                         default:
9689                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9690                 }
9691         }
9692         if (ndr_flags & NDR_BUFFERS) {
9693                 switch (level) {
9694                         case 1:
9695                                 if (r->info1) {
9696                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9697                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9698                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9699                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9700                                 }
9701                         break;
9702
9703                         case 2:
9704                                 if (r->info2) {
9705                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9706                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9707                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9708                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9709                                 }
9710                         break;
9711
9712                         case 3:
9713                                 if (r->info3) {
9714                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9715                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9716                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9717                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9718                                 }
9719                         break;
9720
9721                         case 4:
9722                                 if (r->info4) {
9723                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9724                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9725                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9726                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9727                                 }
9728                         break;
9729
9730                         case 6:
9731                                 if (r->info6) {
9732                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9733                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9734                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9735                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9736                                 }
9737                         break;
9738
9739                         case 8:
9740                                 if (r->info8) {
9741                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9742                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9743                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9744                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9745                                 }
9746                         break;
9747
9748                         default:
9749                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9750                 }
9751         }
9752         return NDR_ERR_SUCCESS;
9753 }
9754
9755 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9756 {
9757         int level;
9758         level = ndr_print_get_switch_value(ndr, r);
9759         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9760         switch (level) {
9761                 case 1:
9762                         ndr_print_ptr(ndr, "info1", r->info1);
9763                         ndr->depth++;
9764                         if (r->info1) {
9765                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9766                         }
9767                         ndr->depth--;
9768                 break;
9769
9770                 case 2:
9771                         ndr_print_ptr(ndr, "info2", r->info2);
9772                         ndr->depth++;
9773                         if (r->info2) {
9774                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9775                         }
9776                         ndr->depth--;
9777                 break;
9778
9779                 case 3:
9780                         ndr_print_ptr(ndr, "info3", r->info3);
9781                         ndr->depth++;
9782                         if (r->info3) {
9783                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9784                         }
9785                         ndr->depth--;
9786                 break;
9787
9788                 case 4:
9789                         ndr_print_ptr(ndr, "info4", r->info4);
9790                         ndr->depth++;
9791                         if (r->info4) {
9792                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9793                         }
9794                         ndr->depth--;
9795                 break;
9796
9797                 case 6:
9798                         ndr_print_ptr(ndr, "info6", r->info6);
9799                         ndr->depth++;
9800                         if (r->info6) {
9801                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9802                         }
9803                         ndr->depth--;
9804                 break;
9805
9806                 case 8:
9807                         ndr_print_ptr(ndr, "info8", r->info8);
9808                         ndr->depth++;
9809                         if (r->info8) {
9810                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9811                         }
9812                         ndr->depth--;
9813                 break;
9814
9815                 default:
9816                         ndr_print_bad_level(ndr, name, level);
9817         }
9818 }
9819
9820 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9821 {
9822         if (ndr_flags & NDR_SCALARS) {
9823                 NDR_CHECK(ndr_push_align(ndr, 4));
9824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9825                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9826                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9827         }
9828         if (ndr_flags & NDR_BUFFERS) {
9829                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9830         }
9831         return NDR_ERR_SUCCESS;
9832 }
9833
9834 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9835 {
9836         if (ndr_flags & NDR_SCALARS) {
9837                 NDR_CHECK(ndr_pull_align(ndr, 4));
9838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9839                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9840                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9841         }
9842         if (ndr_flags & NDR_BUFFERS) {
9843                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9844         }
9845         return NDR_ERR_SUCCESS;
9846 }
9847
9848 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9849 {
9850         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9851         ndr->depth++;
9852         ndr_print_uint32(ndr, "level", r->level);
9853         ndr_print_set_switch_value(ndr, &r->info, r->level);
9854         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9855         ndr->depth--;
9856 }
9857
9858 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9859 {
9860         if (ndr_flags & NDR_SCALARS) {
9861                 NDR_CHECK(ndr_push_align(ndr, 4));
9862                 {
9863                         uint32_t _flags_save_string = ndr->flags;
9864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9865                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9866                         ndr->flags = _flags_save_string;
9867                 }
9868         }
9869         if (ndr_flags & NDR_BUFFERS) {
9870                 {
9871                         uint32_t _flags_save_string = ndr->flags;
9872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9873                         if (r->driver_name) {
9874                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9875                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9876                         }
9877                         ndr->flags = _flags_save_string;
9878                 }
9879         }
9880         return NDR_ERR_SUCCESS;
9881 }
9882
9883 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9884 {
9885         uint32_t _ptr_driver_name;
9886         TALLOC_CTX *_mem_save_driver_name_0;
9887         if (ndr_flags & NDR_SCALARS) {
9888                 NDR_CHECK(ndr_pull_align(ndr, 4));
9889                 {
9890                         uint32_t _flags_save_string = ndr->flags;
9891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9892                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9893                         if (_ptr_driver_name) {
9894                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9895                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9896                         } else {
9897                                 r->driver_name = NULL;
9898                         }
9899                         ndr->flags = _flags_save_string;
9900                 }
9901         }
9902         if (ndr_flags & NDR_BUFFERS) {
9903                 {
9904                         uint32_t _flags_save_string = ndr->flags;
9905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9906                         if (r->driver_name) {
9907                                 uint32_t _relative_save_offset;
9908                                 _relative_save_offset = ndr->offset;
9909                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9910                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9911                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9912                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9913                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9914                                 ndr->offset = _relative_save_offset;
9915                         }
9916                         ndr->flags = _flags_save_string;
9917                 }
9918         }
9919         return NDR_ERR_SUCCESS;
9920 }
9921
9922 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9923 {
9924         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9925         ndr->depth++;
9926         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9927         ndr->depth++;
9928         if (r->driver_name) {
9929                 ndr_print_string(ndr, "driver_name", r->driver_name);
9930         }
9931         ndr->depth--;
9932         ndr->depth--;
9933 }
9934
9935 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9936 {
9937         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9938 }
9939
9940 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9941 {
9942         if (ndr_flags & NDR_SCALARS) {
9943                 NDR_CHECK(ndr_push_align(ndr, 4));
9944                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9945                 {
9946                         uint32_t _flags_save_string = ndr->flags;
9947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9948                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9949                         ndr->flags = _flags_save_string;
9950                 }
9951                 {
9952                         uint32_t _flags_save_string = ndr->flags;
9953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9954                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9955                         ndr->flags = _flags_save_string;
9956                 }
9957                 {
9958                         uint32_t _flags_save_string = ndr->flags;
9959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9960                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9961                         ndr->flags = _flags_save_string;
9962                 }
9963                 {
9964                         uint32_t _flags_save_string = ndr->flags;
9965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9966                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9967                         ndr->flags = _flags_save_string;
9968                 }
9969                 {
9970                         uint32_t _flags_save_string = ndr->flags;
9971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9972                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9973                         ndr->flags = _flags_save_string;
9974                 }
9975         }
9976         if (ndr_flags & NDR_BUFFERS) {
9977                 {
9978                         uint32_t _flags_save_string = ndr->flags;
9979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9980                         if (r->driver_name) {
9981                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9982                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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                         if (r->architecture) {
9990                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9991                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9992                         }
9993                         ndr->flags = _flags_save_string;
9994                 }
9995                 {
9996                         uint32_t _flags_save_string = ndr->flags;
9997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9998                         if (r->driver_path) {
9999                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10000                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10001                         }
10002                         ndr->flags = _flags_save_string;
10003                 }
10004                 {
10005                         uint32_t _flags_save_string = ndr->flags;
10006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10007                         if (r->data_file) {
10008                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10009                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10010                         }
10011                         ndr->flags = _flags_save_string;
10012                 }
10013                 {
10014                         uint32_t _flags_save_string = ndr->flags;
10015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10016                         if (r->config_file) {
10017                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10018                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10019                         }
10020                         ndr->flags = _flags_save_string;
10021                 }
10022         }
10023         return NDR_ERR_SUCCESS;
10024 }
10025
10026 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10027 {
10028         uint32_t _ptr_driver_name;
10029         TALLOC_CTX *_mem_save_driver_name_0;
10030         uint32_t _ptr_architecture;
10031         TALLOC_CTX *_mem_save_architecture_0;
10032         uint32_t _ptr_driver_path;
10033         TALLOC_CTX *_mem_save_driver_path_0;
10034         uint32_t _ptr_data_file;
10035         TALLOC_CTX *_mem_save_data_file_0;
10036         uint32_t _ptr_config_file;
10037         TALLOC_CTX *_mem_save_config_file_0;
10038         if (ndr_flags & NDR_SCALARS) {
10039                 NDR_CHECK(ndr_pull_align(ndr, 4));
10040                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10041                 {
10042                         uint32_t _flags_save_string = ndr->flags;
10043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10044                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10045                         if (_ptr_driver_name) {
10046                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10047                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10048                         } else {
10049                                 r->driver_name = NULL;
10050                         }
10051                         ndr->flags = _flags_save_string;
10052                 }
10053                 {
10054                         uint32_t _flags_save_string = ndr->flags;
10055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10056                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10057                         if (_ptr_architecture) {
10058                                 NDR_PULL_ALLOC(ndr, r->architecture);
10059                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10060                         } else {
10061                                 r->architecture = NULL;
10062                         }
10063                         ndr->flags = _flags_save_string;
10064                 }
10065                 {
10066                         uint32_t _flags_save_string = ndr->flags;
10067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10068                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10069                         if (_ptr_driver_path) {
10070                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10071                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10072                         } else {
10073                                 r->driver_path = NULL;
10074                         }
10075                         ndr->flags = _flags_save_string;
10076                 }
10077                 {
10078                         uint32_t _flags_save_string = ndr->flags;
10079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10080                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10081                         if (_ptr_data_file) {
10082                                 NDR_PULL_ALLOC(ndr, r->data_file);
10083                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10084                         } else {
10085                                 r->data_file = NULL;
10086                         }
10087                         ndr->flags = _flags_save_string;
10088                 }
10089                 {
10090                         uint32_t _flags_save_string = ndr->flags;
10091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10092                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10093                         if (_ptr_config_file) {
10094                                 NDR_PULL_ALLOC(ndr, r->config_file);
10095                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10096                         } else {
10097                                 r->config_file = NULL;
10098                         }
10099                         ndr->flags = _flags_save_string;
10100                 }
10101         }
10102         if (ndr_flags & NDR_BUFFERS) {
10103                 {
10104                         uint32_t _flags_save_string = ndr->flags;
10105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10106                         if (r->driver_name) {
10107                                 uint32_t _relative_save_offset;
10108                                 _relative_save_offset = ndr->offset;
10109                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10110                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10111                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10112                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10113                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10114                                 ndr->offset = _relative_save_offset;
10115                         }
10116                         ndr->flags = _flags_save_string;
10117                 }
10118                 {
10119                         uint32_t _flags_save_string = ndr->flags;
10120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10121                         if (r->architecture) {
10122                                 uint32_t _relative_save_offset;
10123                                 _relative_save_offset = ndr->offset;
10124                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10125                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10126                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10127                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10128                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10129                                 ndr->offset = _relative_save_offset;
10130                         }
10131                         ndr->flags = _flags_save_string;
10132                 }
10133                 {
10134                         uint32_t _flags_save_string = ndr->flags;
10135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10136                         if (r->driver_path) {
10137                                 uint32_t _relative_save_offset;
10138                                 _relative_save_offset = ndr->offset;
10139                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10140                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10141                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10142                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10143                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10144                                 ndr->offset = _relative_save_offset;
10145                         }
10146                         ndr->flags = _flags_save_string;
10147                 }
10148                 {
10149                         uint32_t _flags_save_string = ndr->flags;
10150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10151                         if (r->data_file) {
10152                                 uint32_t _relative_save_offset;
10153                                 _relative_save_offset = ndr->offset;
10154                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10155                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10156                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10157                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10158                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10159                                 ndr->offset = _relative_save_offset;
10160                         }
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                         if (r->config_file) {
10167                                 uint32_t _relative_save_offset;
10168                                 _relative_save_offset = ndr->offset;
10169                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10170                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10171                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10172                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10173                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10174                                 ndr->offset = _relative_save_offset;
10175                         }
10176                         ndr->flags = _flags_save_string;
10177                 }
10178         }
10179         return NDR_ERR_SUCCESS;
10180 }
10181
10182 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10183 {
10184         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10185         ndr->depth++;
10186         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10187         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10188         ndr->depth++;
10189         if (r->driver_name) {
10190                 ndr_print_string(ndr, "driver_name", r->driver_name);
10191         }
10192         ndr->depth--;
10193         ndr_print_ptr(ndr, "architecture", r->architecture);
10194         ndr->depth++;
10195         if (r->architecture) {
10196                 ndr_print_string(ndr, "architecture", r->architecture);
10197         }
10198         ndr->depth--;
10199         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10200         ndr->depth++;
10201         if (r->driver_path) {
10202                 ndr_print_string(ndr, "driver_path", r->driver_path);
10203         }
10204         ndr->depth--;
10205         ndr_print_ptr(ndr, "data_file", r->data_file);
10206         ndr->depth++;
10207         if (r->data_file) {
10208                 ndr_print_string(ndr, "data_file", r->data_file);
10209         }
10210         ndr->depth--;
10211         ndr_print_ptr(ndr, "config_file", r->config_file);
10212         ndr->depth++;
10213         if (r->config_file) {
10214                 ndr_print_string(ndr, "config_file", r->config_file);
10215         }
10216         ndr->depth--;
10217         ndr->depth--;
10218 }
10219
10220 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10221 {
10222         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10223 }
10224
10225 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10226 {
10227         if (ndr_flags & NDR_SCALARS) {
10228                 NDR_CHECK(ndr_push_align(ndr, 4));
10229                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10230                 {
10231                         uint32_t _flags_save_string = ndr->flags;
10232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10233                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10234                         ndr->flags = _flags_save_string;
10235                 }
10236                 {
10237                         uint32_t _flags_save_string = ndr->flags;
10238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10239                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10240                         ndr->flags = _flags_save_string;
10241                 }
10242                 {
10243                         uint32_t _flags_save_string = ndr->flags;
10244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10245                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10246                         ndr->flags = _flags_save_string;
10247                 }
10248                 {
10249                         uint32_t _flags_save_string = ndr->flags;
10250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10251                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10252                         ndr->flags = _flags_save_string;
10253                 }
10254                 {
10255                         uint32_t _flags_save_string = ndr->flags;
10256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10257                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10258                         ndr->flags = _flags_save_string;
10259                 }
10260                 {
10261                         uint32_t _flags_save_string = ndr->flags;
10262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10263                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10264                         ndr->flags = _flags_save_string;
10265                 }
10266                 {
10267                         uint32_t _flags_save_string_array = ndr->flags;
10268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10269                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10270                         ndr->flags = _flags_save_string_array;
10271                 }
10272                 {
10273                         uint32_t _flags_save_string = ndr->flags;
10274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10275                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10276                         ndr->flags = _flags_save_string;
10277                 }
10278                 {
10279                         uint32_t _flags_save_string = ndr->flags;
10280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10281                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10282                         ndr->flags = _flags_save_string;
10283                 }
10284         }
10285         if (ndr_flags & NDR_BUFFERS) {
10286                 {
10287                         uint32_t _flags_save_string = ndr->flags;
10288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10289                         if (r->driver_name) {
10290                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10291                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10292                         }
10293                         ndr->flags = _flags_save_string;
10294                 }
10295                 {
10296                         uint32_t _flags_save_string = ndr->flags;
10297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10298                         if (r->architecture) {
10299                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10300                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10301                         }
10302                         ndr->flags = _flags_save_string;
10303                 }
10304                 {
10305                         uint32_t _flags_save_string = ndr->flags;
10306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10307                         if (r->driver_path) {
10308                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10309                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10310                         }
10311                         ndr->flags = _flags_save_string;
10312                 }
10313                 {
10314                         uint32_t _flags_save_string = ndr->flags;
10315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10316                         if (r->data_file) {
10317                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10318                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10319                         }
10320                         ndr->flags = _flags_save_string;
10321                 }
10322                 {
10323                         uint32_t _flags_save_string = ndr->flags;
10324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10325                         if (r->config_file) {
10326                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10327                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10328                         }
10329                         ndr->flags = _flags_save_string;
10330                 }
10331                 {
10332                         uint32_t _flags_save_string = ndr->flags;
10333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10334                         if (r->help_file) {
10335                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10336                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10337                         }
10338                         ndr->flags = _flags_save_string;
10339                 }
10340                 {
10341                         uint32_t _flags_save_string_array = ndr->flags;
10342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10343                         if (r->dependent_files) {
10344                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10345                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10346                         }
10347                         ndr->flags = _flags_save_string_array;
10348                 }
10349                 {
10350                         uint32_t _flags_save_string = ndr->flags;
10351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10352                         if (r->monitor_name) {
10353                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10354                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10355                         }
10356                         ndr->flags = _flags_save_string;
10357                 }
10358                 {
10359                         uint32_t _flags_save_string = ndr->flags;
10360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10361                         if (r->default_datatype) {
10362                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10363                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10364                         }
10365                         ndr->flags = _flags_save_string;
10366                 }
10367         }
10368         return NDR_ERR_SUCCESS;
10369 }
10370
10371 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10372 {
10373         uint32_t _ptr_driver_name;
10374         TALLOC_CTX *_mem_save_driver_name_0;
10375         uint32_t _ptr_architecture;
10376         TALLOC_CTX *_mem_save_architecture_0;
10377         uint32_t _ptr_driver_path;
10378         TALLOC_CTX *_mem_save_driver_path_0;
10379         uint32_t _ptr_data_file;
10380         TALLOC_CTX *_mem_save_data_file_0;
10381         uint32_t _ptr_config_file;
10382         TALLOC_CTX *_mem_save_config_file_0;
10383         uint32_t _ptr_help_file;
10384         TALLOC_CTX *_mem_save_help_file_0;
10385         uint32_t _ptr_dependent_files;
10386         TALLOC_CTX *_mem_save_dependent_files_0;
10387         uint32_t _ptr_monitor_name;
10388         TALLOC_CTX *_mem_save_monitor_name_0;
10389         uint32_t _ptr_default_datatype;
10390         TALLOC_CTX *_mem_save_default_datatype_0;
10391         if (ndr_flags & NDR_SCALARS) {
10392                 NDR_CHECK(ndr_pull_align(ndr, 4));
10393                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10394                 {
10395                         uint32_t _flags_save_string = ndr->flags;
10396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10398                         if (_ptr_driver_name) {
10399                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10401                         } else {
10402                                 r->driver_name = NULL;
10403                         }
10404                         ndr->flags = _flags_save_string;
10405                 }
10406                 {
10407                         uint32_t _flags_save_string = ndr->flags;
10408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10409                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10410                         if (_ptr_architecture) {
10411                                 NDR_PULL_ALLOC(ndr, r->architecture);
10412                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10413                         } else {
10414                                 r->architecture = NULL;
10415                         }
10416                         ndr->flags = _flags_save_string;
10417                 }
10418                 {
10419                         uint32_t _flags_save_string = ndr->flags;
10420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10421                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10422                         if (_ptr_driver_path) {
10423                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10424                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10425                         } else {
10426                                 r->driver_path = NULL;
10427                         }
10428                         ndr->flags = _flags_save_string;
10429                 }
10430                 {
10431                         uint32_t _flags_save_string = ndr->flags;
10432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10433                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10434                         if (_ptr_data_file) {
10435                                 NDR_PULL_ALLOC(ndr, r->data_file);
10436                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10437                         } else {
10438                                 r->data_file = NULL;
10439                         }
10440                         ndr->flags = _flags_save_string;
10441                 }
10442                 {
10443                         uint32_t _flags_save_string = ndr->flags;
10444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10445                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10446                         if (_ptr_config_file) {
10447                                 NDR_PULL_ALLOC(ndr, r->config_file);
10448                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10449                         } else {
10450                                 r->config_file = NULL;
10451                         }
10452                         ndr->flags = _flags_save_string;
10453                 }
10454                 {
10455                         uint32_t _flags_save_string = ndr->flags;
10456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10457                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10458                         if (_ptr_help_file) {
10459                                 NDR_PULL_ALLOC(ndr, r->help_file);
10460                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10461                         } else {
10462                                 r->help_file = NULL;
10463                         }
10464                         ndr->flags = _flags_save_string;
10465                 }
10466                 {
10467                         uint32_t _flags_save_string_array = ndr->flags;
10468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10469                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10470                         if (_ptr_dependent_files) {
10471                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10472                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10473                         } else {
10474                                 r->dependent_files = NULL;
10475                         }
10476                         ndr->flags = _flags_save_string_array;
10477                 }
10478                 {
10479                         uint32_t _flags_save_string = ndr->flags;
10480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10481                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10482                         if (_ptr_monitor_name) {
10483                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10484                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10485                         } else {
10486                                 r->monitor_name = NULL;
10487                         }
10488                         ndr->flags = _flags_save_string;
10489                 }
10490                 {
10491                         uint32_t _flags_save_string = ndr->flags;
10492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10493                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10494                         if (_ptr_default_datatype) {
10495                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10496                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10497                         } else {
10498                                 r->default_datatype = NULL;
10499                         }
10500                         ndr->flags = _flags_save_string;
10501                 }
10502         }
10503         if (ndr_flags & NDR_BUFFERS) {
10504                 {
10505                         uint32_t _flags_save_string = ndr->flags;
10506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10507                         if (r->driver_name) {
10508                                 uint32_t _relative_save_offset;
10509                                 _relative_save_offset = ndr->offset;
10510                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10511                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10512                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10513                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10514                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10515                                 ndr->offset = _relative_save_offset;
10516                         }
10517                         ndr->flags = _flags_save_string;
10518                 }
10519                 {
10520                         uint32_t _flags_save_string = ndr->flags;
10521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10522                         if (r->architecture) {
10523                                 uint32_t _relative_save_offset;
10524                                 _relative_save_offset = ndr->offset;
10525                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10526                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10527                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10528                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10529                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10530                                 ndr->offset = _relative_save_offset;
10531                         }
10532                         ndr->flags = _flags_save_string;
10533                 }
10534                 {
10535                         uint32_t _flags_save_string = ndr->flags;
10536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10537                         if (r->driver_path) {
10538                                 uint32_t _relative_save_offset;
10539                                 _relative_save_offset = ndr->offset;
10540                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10541                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10542                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10543                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10544                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10545                                 ndr->offset = _relative_save_offset;
10546                         }
10547                         ndr->flags = _flags_save_string;
10548                 }
10549                 {
10550                         uint32_t _flags_save_string = ndr->flags;
10551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10552                         if (r->data_file) {
10553                                 uint32_t _relative_save_offset;
10554                                 _relative_save_offset = ndr->offset;
10555                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10556                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10557                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10558                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10559                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10560                                 ndr->offset = _relative_save_offset;
10561                         }
10562                         ndr->flags = _flags_save_string;
10563                 }
10564                 {
10565                         uint32_t _flags_save_string = ndr->flags;
10566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10567                         if (r->config_file) {
10568                                 uint32_t _relative_save_offset;
10569                                 _relative_save_offset = ndr->offset;
10570                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10571                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10572                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10573                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10574                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10575                                 ndr->offset = _relative_save_offset;
10576                         }
10577                         ndr->flags = _flags_save_string;
10578                 }
10579                 {
10580                         uint32_t _flags_save_string = ndr->flags;
10581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10582                         if (r->help_file) {
10583                                 uint32_t _relative_save_offset;
10584                                 _relative_save_offset = ndr->offset;
10585                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10586                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10587                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10588                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10589                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10590                                 ndr->offset = _relative_save_offset;
10591                         }
10592                         ndr->flags = _flags_save_string;
10593                 }
10594                 {
10595                         uint32_t _flags_save_string_array = ndr->flags;
10596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10597                         if (r->dependent_files) {
10598                                 uint32_t _relative_save_offset;
10599                                 _relative_save_offset = ndr->offset;
10600                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10601                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10602                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10603                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10604                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10605                                 ndr->offset = _relative_save_offset;
10606                         }
10607                         ndr->flags = _flags_save_string_array;
10608                 }
10609                 {
10610                         uint32_t _flags_save_string = ndr->flags;
10611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10612                         if (r->monitor_name) {
10613                                 uint32_t _relative_save_offset;
10614                                 _relative_save_offset = ndr->offset;
10615                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10616                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10617                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10618                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10619                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10620                                 ndr->offset = _relative_save_offset;
10621                         }
10622                         ndr->flags = _flags_save_string;
10623                 }
10624                 {
10625                         uint32_t _flags_save_string = ndr->flags;
10626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10627                         if (r->default_datatype) {
10628                                 uint32_t _relative_save_offset;
10629                                 _relative_save_offset = ndr->offset;
10630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10631                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10632                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10633                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10635                                 ndr->offset = _relative_save_offset;
10636                         }
10637                         ndr->flags = _flags_save_string;
10638                 }
10639         }
10640         return NDR_ERR_SUCCESS;
10641 }
10642
10643 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10644 {
10645         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10646         ndr->depth++;
10647         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10648         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10649         ndr->depth++;
10650         if (r->driver_name) {
10651                 ndr_print_string(ndr, "driver_name", r->driver_name);
10652         }
10653         ndr->depth--;
10654         ndr_print_ptr(ndr, "architecture", r->architecture);
10655         ndr->depth++;
10656         if (r->architecture) {
10657                 ndr_print_string(ndr, "architecture", r->architecture);
10658         }
10659         ndr->depth--;
10660         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10661         ndr->depth++;
10662         if (r->driver_path) {
10663                 ndr_print_string(ndr, "driver_path", r->driver_path);
10664         }
10665         ndr->depth--;
10666         ndr_print_ptr(ndr, "data_file", r->data_file);
10667         ndr->depth++;
10668         if (r->data_file) {
10669                 ndr_print_string(ndr, "data_file", r->data_file);
10670         }
10671         ndr->depth--;
10672         ndr_print_ptr(ndr, "config_file", r->config_file);
10673         ndr->depth++;
10674         if (r->config_file) {
10675                 ndr_print_string(ndr, "config_file", r->config_file);
10676         }
10677         ndr->depth--;
10678         ndr_print_ptr(ndr, "help_file", r->help_file);
10679         ndr->depth++;
10680         if (r->help_file) {
10681                 ndr_print_string(ndr, "help_file", r->help_file);
10682         }
10683         ndr->depth--;
10684         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10685         ndr->depth++;
10686         if (r->dependent_files) {
10687                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10688         }
10689         ndr->depth--;
10690         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10691         ndr->depth++;
10692         if (r->monitor_name) {
10693                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10694         }
10695         ndr->depth--;
10696         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10697         ndr->depth++;
10698         if (r->default_datatype) {
10699                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10700         }
10701         ndr->depth--;
10702         ndr->depth--;
10703 }
10704
10705 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10706 {
10707         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10708 }
10709
10710 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10711 {
10712         if (ndr_flags & NDR_SCALARS) {
10713                 NDR_CHECK(ndr_push_align(ndr, 4));
10714                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10715                 {
10716                         uint32_t _flags_save_string = ndr->flags;
10717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10718                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10719                         ndr->flags = _flags_save_string;
10720                 }
10721                 {
10722                         uint32_t _flags_save_string = ndr->flags;
10723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10724                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10725                         ndr->flags = _flags_save_string;
10726                 }
10727                 {
10728                         uint32_t _flags_save_string = ndr->flags;
10729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10730                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10731                         ndr->flags = _flags_save_string;
10732                 }
10733                 {
10734                         uint32_t _flags_save_string = ndr->flags;
10735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10736                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10737                         ndr->flags = _flags_save_string;
10738                 }
10739                 {
10740                         uint32_t _flags_save_string = ndr->flags;
10741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10742                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10743                         ndr->flags = _flags_save_string;
10744                 }
10745                 {
10746                         uint32_t _flags_save_string = ndr->flags;
10747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10748                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10749                         ndr->flags = _flags_save_string;
10750                 }
10751                 {
10752                         uint32_t _flags_save_string_array = ndr->flags;
10753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10754                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10755                         ndr->flags = _flags_save_string_array;
10756                 }
10757                 {
10758                         uint32_t _flags_save_string = ndr->flags;
10759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10760                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10761                         ndr->flags = _flags_save_string;
10762                 }
10763                 {
10764                         uint32_t _flags_save_string = ndr->flags;
10765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10766                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10767                         ndr->flags = _flags_save_string;
10768                 }
10769                 {
10770                         uint32_t _flags_save_string_array = ndr->flags;
10771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10772                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10773                         ndr->flags = _flags_save_string_array;
10774                 }
10775         }
10776         if (ndr_flags & NDR_BUFFERS) {
10777                 {
10778                         uint32_t _flags_save_string = ndr->flags;
10779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10780                         if (r->driver_name) {
10781                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10783                         }
10784                         ndr->flags = _flags_save_string;
10785                 }
10786                 {
10787                         uint32_t _flags_save_string = ndr->flags;
10788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10789                         if (r->architecture) {
10790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10792                         }
10793                         ndr->flags = _flags_save_string;
10794                 }
10795                 {
10796                         uint32_t _flags_save_string = ndr->flags;
10797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10798                         if (r->driver_path) {
10799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10801                         }
10802                         ndr->flags = _flags_save_string;
10803                 }
10804                 {
10805                         uint32_t _flags_save_string = ndr->flags;
10806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10807                         if (r->data_file) {
10808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10810                         }
10811                         ndr->flags = _flags_save_string;
10812                 }
10813                 {
10814                         uint32_t _flags_save_string = ndr->flags;
10815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10816                         if (r->config_file) {
10817                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10818                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10819                         }
10820                         ndr->flags = _flags_save_string;
10821                 }
10822                 {
10823                         uint32_t _flags_save_string = ndr->flags;
10824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10825                         if (r->help_file) {
10826                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10827                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10828                         }
10829                         ndr->flags = _flags_save_string;
10830                 }
10831                 {
10832                         uint32_t _flags_save_string_array = ndr->flags;
10833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10834                         if (r->dependent_files) {
10835                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10836                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10837                         }
10838                         ndr->flags = _flags_save_string_array;
10839                 }
10840                 {
10841                         uint32_t _flags_save_string = ndr->flags;
10842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10843                         if (r->monitor_name) {
10844                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10845                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10846                         }
10847                         ndr->flags = _flags_save_string;
10848                 }
10849                 {
10850                         uint32_t _flags_save_string = ndr->flags;
10851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10852                         if (r->default_datatype) {
10853                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10854                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10855                         }
10856                         ndr->flags = _flags_save_string;
10857                 }
10858                 {
10859                         uint32_t _flags_save_string_array = ndr->flags;
10860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10861                         if (r->previous_names) {
10862                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10863                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10864                         }
10865                         ndr->flags = _flags_save_string_array;
10866                 }
10867         }
10868         return NDR_ERR_SUCCESS;
10869 }
10870
10871 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10872 {
10873         uint32_t _ptr_driver_name;
10874         TALLOC_CTX *_mem_save_driver_name_0;
10875         uint32_t _ptr_architecture;
10876         TALLOC_CTX *_mem_save_architecture_0;
10877         uint32_t _ptr_driver_path;
10878         TALLOC_CTX *_mem_save_driver_path_0;
10879         uint32_t _ptr_data_file;
10880         TALLOC_CTX *_mem_save_data_file_0;
10881         uint32_t _ptr_config_file;
10882         TALLOC_CTX *_mem_save_config_file_0;
10883         uint32_t _ptr_help_file;
10884         TALLOC_CTX *_mem_save_help_file_0;
10885         uint32_t _ptr_dependent_files;
10886         TALLOC_CTX *_mem_save_dependent_files_0;
10887         uint32_t _ptr_monitor_name;
10888         TALLOC_CTX *_mem_save_monitor_name_0;
10889         uint32_t _ptr_default_datatype;
10890         TALLOC_CTX *_mem_save_default_datatype_0;
10891         uint32_t _ptr_previous_names;
10892         TALLOC_CTX *_mem_save_previous_names_0;
10893         if (ndr_flags & NDR_SCALARS) {
10894                 NDR_CHECK(ndr_pull_align(ndr, 4));
10895                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10896                 {
10897                         uint32_t _flags_save_string = ndr->flags;
10898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10899                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10900                         if (_ptr_driver_name) {
10901                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10902                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10903                         } else {
10904                                 r->driver_name = NULL;
10905                         }
10906                         ndr->flags = _flags_save_string;
10907                 }
10908                 {
10909                         uint32_t _flags_save_string = ndr->flags;
10910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10911                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10912                         if (_ptr_architecture) {
10913                                 NDR_PULL_ALLOC(ndr, r->architecture);
10914                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10915                         } else {
10916                                 r->architecture = NULL;
10917                         }
10918                         ndr->flags = _flags_save_string;
10919                 }
10920                 {
10921                         uint32_t _flags_save_string = ndr->flags;
10922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10923                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10924                         if (_ptr_driver_path) {
10925                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10926                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10927                         } else {
10928                                 r->driver_path = NULL;
10929                         }
10930                         ndr->flags = _flags_save_string;
10931                 }
10932                 {
10933                         uint32_t _flags_save_string = ndr->flags;
10934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10935                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10936                         if (_ptr_data_file) {
10937                                 NDR_PULL_ALLOC(ndr, r->data_file);
10938                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10939                         } else {
10940                                 r->data_file = NULL;
10941                         }
10942                         ndr->flags = _flags_save_string;
10943                 }
10944                 {
10945                         uint32_t _flags_save_string = ndr->flags;
10946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10947                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10948                         if (_ptr_config_file) {
10949                                 NDR_PULL_ALLOC(ndr, r->config_file);
10950                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10951                         } else {
10952                                 r->config_file = NULL;
10953                         }
10954                         ndr->flags = _flags_save_string;
10955                 }
10956                 {
10957                         uint32_t _flags_save_string = ndr->flags;
10958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10959                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10960                         if (_ptr_help_file) {
10961                                 NDR_PULL_ALLOC(ndr, r->help_file);
10962                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10963                         } else {
10964                                 r->help_file = NULL;
10965                         }
10966                         ndr->flags = _flags_save_string;
10967                 }
10968                 {
10969                         uint32_t _flags_save_string_array = ndr->flags;
10970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10971                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10972                         if (_ptr_dependent_files) {
10973                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10974                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10975                         } else {
10976                                 r->dependent_files = NULL;
10977                         }
10978                         ndr->flags = _flags_save_string_array;
10979                 }
10980                 {
10981                         uint32_t _flags_save_string = ndr->flags;
10982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10983                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10984                         if (_ptr_monitor_name) {
10985                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10986                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10987                         } else {
10988                                 r->monitor_name = NULL;
10989                         }
10990                         ndr->flags = _flags_save_string;
10991                 }
10992                 {
10993                         uint32_t _flags_save_string = ndr->flags;
10994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10995                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10996                         if (_ptr_default_datatype) {
10997                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10998                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10999                         } else {
11000                                 r->default_datatype = NULL;
11001                         }
11002                         ndr->flags = _flags_save_string;
11003                 }
11004                 {
11005                         uint32_t _flags_save_string_array = ndr->flags;
11006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11007                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11008                         if (_ptr_previous_names) {
11009                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11010                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11011                         } else {
11012                                 r->previous_names = NULL;
11013                         }
11014                         ndr->flags = _flags_save_string_array;
11015                 }
11016         }
11017         if (ndr_flags & NDR_BUFFERS) {
11018                 {
11019                         uint32_t _flags_save_string = ndr->flags;
11020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11021                         if (r->driver_name) {
11022                                 uint32_t _relative_save_offset;
11023                                 _relative_save_offset = ndr->offset;
11024                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11025                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11026                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11027                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11028                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11029                                 ndr->offset = _relative_save_offset;
11030                         }
11031                         ndr->flags = _flags_save_string;
11032                 }
11033                 {
11034                         uint32_t _flags_save_string = ndr->flags;
11035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11036                         if (r->architecture) {
11037                                 uint32_t _relative_save_offset;
11038                                 _relative_save_offset = ndr->offset;
11039                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11040                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11041                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11042                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11043                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11044                                 ndr->offset = _relative_save_offset;
11045                         }
11046                         ndr->flags = _flags_save_string;
11047                 }
11048                 {
11049                         uint32_t _flags_save_string = ndr->flags;
11050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11051                         if (r->driver_path) {
11052                                 uint32_t _relative_save_offset;
11053                                 _relative_save_offset = ndr->offset;
11054                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11055                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11056                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11057                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11058                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11059                                 ndr->offset = _relative_save_offset;
11060                         }
11061                         ndr->flags = _flags_save_string;
11062                 }
11063                 {
11064                         uint32_t _flags_save_string = ndr->flags;
11065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11066                         if (r->data_file) {
11067                                 uint32_t _relative_save_offset;
11068                                 _relative_save_offset = ndr->offset;
11069                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11070                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11071                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11072                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11073                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11074                                 ndr->offset = _relative_save_offset;
11075                         }
11076                         ndr->flags = _flags_save_string;
11077                 }
11078                 {
11079                         uint32_t _flags_save_string = ndr->flags;
11080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11081                         if (r->config_file) {
11082                                 uint32_t _relative_save_offset;
11083                                 _relative_save_offset = ndr->offset;
11084                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11085                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11086                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11087                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11088                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11089                                 ndr->offset = _relative_save_offset;
11090                         }
11091                         ndr->flags = _flags_save_string;
11092                 }
11093                 {
11094                         uint32_t _flags_save_string = ndr->flags;
11095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11096                         if (r->help_file) {
11097                                 uint32_t _relative_save_offset;
11098                                 _relative_save_offset = ndr->offset;
11099                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11100                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11101                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11102                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11103                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11104                                 ndr->offset = _relative_save_offset;
11105                         }
11106                         ndr->flags = _flags_save_string;
11107                 }
11108                 {
11109                         uint32_t _flags_save_string_array = ndr->flags;
11110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11111                         if (r->dependent_files) {
11112                                 uint32_t _relative_save_offset;
11113                                 _relative_save_offset = ndr->offset;
11114                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11115                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11116                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11117                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11118                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11119                                 ndr->offset = _relative_save_offset;
11120                         }
11121                         ndr->flags = _flags_save_string_array;
11122                 }
11123                 {
11124                         uint32_t _flags_save_string = ndr->flags;
11125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11126                         if (r->monitor_name) {
11127                                 uint32_t _relative_save_offset;
11128                                 _relative_save_offset = ndr->offset;
11129                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11130                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11131                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11132                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11133                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11134                                 ndr->offset = _relative_save_offset;
11135                         }
11136                         ndr->flags = _flags_save_string;
11137                 }
11138                 {
11139                         uint32_t _flags_save_string = ndr->flags;
11140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11141                         if (r->default_datatype) {
11142                                 uint32_t _relative_save_offset;
11143                                 _relative_save_offset = ndr->offset;
11144                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11145                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11146                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11147                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11148                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11149                                 ndr->offset = _relative_save_offset;
11150                         }
11151                         ndr->flags = _flags_save_string;
11152                 }
11153                 {
11154                         uint32_t _flags_save_string_array = ndr->flags;
11155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11156                         if (r->previous_names) {
11157                                 uint32_t _relative_save_offset;
11158                                 _relative_save_offset = ndr->offset;
11159                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11160                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11161                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11162                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11163                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11164                                 ndr->offset = _relative_save_offset;
11165                         }
11166                         ndr->flags = _flags_save_string_array;
11167                 }
11168         }
11169         return NDR_ERR_SUCCESS;
11170 }
11171
11172 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11173 {
11174         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11175         ndr->depth++;
11176         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11177         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11178         ndr->depth++;
11179         if (r->driver_name) {
11180                 ndr_print_string(ndr, "driver_name", r->driver_name);
11181         }
11182         ndr->depth--;
11183         ndr_print_ptr(ndr, "architecture", r->architecture);
11184         ndr->depth++;
11185         if (r->architecture) {
11186                 ndr_print_string(ndr, "architecture", r->architecture);
11187         }
11188         ndr->depth--;
11189         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11190         ndr->depth++;
11191         if (r->driver_path) {
11192                 ndr_print_string(ndr, "driver_path", r->driver_path);
11193         }
11194         ndr->depth--;
11195         ndr_print_ptr(ndr, "data_file", r->data_file);
11196         ndr->depth++;
11197         if (r->data_file) {
11198                 ndr_print_string(ndr, "data_file", r->data_file);
11199         }
11200         ndr->depth--;
11201         ndr_print_ptr(ndr, "config_file", r->config_file);
11202         ndr->depth++;
11203         if (r->config_file) {
11204                 ndr_print_string(ndr, "config_file", r->config_file);
11205         }
11206         ndr->depth--;
11207         ndr_print_ptr(ndr, "help_file", r->help_file);
11208         ndr->depth++;
11209         if (r->help_file) {
11210                 ndr_print_string(ndr, "help_file", r->help_file);
11211         }
11212         ndr->depth--;
11213         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11214         ndr->depth++;
11215         if (r->dependent_files) {
11216                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11217         }
11218         ndr->depth--;
11219         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11220         ndr->depth++;
11221         if (r->monitor_name) {
11222                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11223         }
11224         ndr->depth--;
11225         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11226         ndr->depth++;
11227         if (r->default_datatype) {
11228                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11229         }
11230         ndr->depth--;
11231         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11232         ndr->depth++;
11233         if (r->previous_names) {
11234                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11235         }
11236         ndr->depth--;
11237         ndr->depth--;
11238 }
11239
11240 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11241 {
11242         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11243 }
11244
11245 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11246 {
11247         if (ndr_flags & NDR_SCALARS) {
11248                 NDR_CHECK(ndr_push_align(ndr, 4));
11249                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11250                 {
11251                         uint32_t _flags_save_string = ndr->flags;
11252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11253                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11254                         ndr->flags = _flags_save_string;
11255                 }
11256                 {
11257                         uint32_t _flags_save_string = ndr->flags;
11258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11260                         ndr->flags = _flags_save_string;
11261                 }
11262                 {
11263                         uint32_t _flags_save_string = ndr->flags;
11264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11266                         ndr->flags = _flags_save_string;
11267                 }
11268                 {
11269                         uint32_t _flags_save_string = ndr->flags;
11270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11271                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11272                         ndr->flags = _flags_save_string;
11273                 }
11274                 {
11275                         uint32_t _flags_save_string = ndr->flags;
11276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11277                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11278                         ndr->flags = _flags_save_string;
11279                 }
11280                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
11281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11283         }
11284         if (ndr_flags & NDR_BUFFERS) {
11285                 {
11286                         uint32_t _flags_save_string = ndr->flags;
11287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11288                         if (r->driver_name) {
11289                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11290                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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                         if (r->architecture) {
11298                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11299                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11300                         }
11301                         ndr->flags = _flags_save_string;
11302                 }
11303                 {
11304                         uint32_t _flags_save_string = ndr->flags;
11305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11306                         if (r->driver_path) {
11307                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11308                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11309                         }
11310                         ndr->flags = _flags_save_string;
11311                 }
11312                 {
11313                         uint32_t _flags_save_string = ndr->flags;
11314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11315                         if (r->data_file) {
11316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11318                         }
11319                         ndr->flags = _flags_save_string;
11320                 }
11321                 {
11322                         uint32_t _flags_save_string = ndr->flags;
11323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11324                         if (r->config_file) {
11325                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11326                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11327                         }
11328                         ndr->flags = _flags_save_string;
11329                 }
11330         }
11331         return NDR_ERR_SUCCESS;
11332 }
11333
11334 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11335 {
11336         uint32_t _ptr_driver_name;
11337         TALLOC_CTX *_mem_save_driver_name_0;
11338         uint32_t _ptr_architecture;
11339         TALLOC_CTX *_mem_save_architecture_0;
11340         uint32_t _ptr_driver_path;
11341         TALLOC_CTX *_mem_save_driver_path_0;
11342         uint32_t _ptr_data_file;
11343         TALLOC_CTX *_mem_save_data_file_0;
11344         uint32_t _ptr_config_file;
11345         TALLOC_CTX *_mem_save_config_file_0;
11346         if (ndr_flags & NDR_SCALARS) {
11347                 NDR_CHECK(ndr_pull_align(ndr, 4));
11348                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11349                 {
11350                         uint32_t _flags_save_string = ndr->flags;
11351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11352                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11353                         if (_ptr_driver_name) {
11354                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11355                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11356                         } else {
11357                                 r->driver_name = NULL;
11358                         }
11359                         ndr->flags = _flags_save_string;
11360                 }
11361                 {
11362                         uint32_t _flags_save_string = ndr->flags;
11363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11364                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11365                         if (_ptr_architecture) {
11366                                 NDR_PULL_ALLOC(ndr, r->architecture);
11367                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11368                         } else {
11369                                 r->architecture = NULL;
11370                         }
11371                         ndr->flags = _flags_save_string;
11372                 }
11373                 {
11374                         uint32_t _flags_save_string = ndr->flags;
11375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11376                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11377                         if (_ptr_driver_path) {
11378                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11379                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11380                         } else {
11381                                 r->driver_path = NULL;
11382                         }
11383                         ndr->flags = _flags_save_string;
11384                 }
11385                 {
11386                         uint32_t _flags_save_string = ndr->flags;
11387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11388                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11389                         if (_ptr_data_file) {
11390                                 NDR_PULL_ALLOC(ndr, r->data_file);
11391                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11392                         } else {
11393                                 r->data_file = NULL;
11394                         }
11395                         ndr->flags = _flags_save_string;
11396                 }
11397                 {
11398                         uint32_t _flags_save_string = ndr->flags;
11399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11400                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11401                         if (_ptr_config_file) {
11402                                 NDR_PULL_ALLOC(ndr, r->config_file);
11403                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11404                         } else {
11405                                 r->config_file = NULL;
11406                         }
11407                         ndr->flags = _flags_save_string;
11408                 }
11409                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
11410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11412         }
11413         if (ndr_flags & NDR_BUFFERS) {
11414                 {
11415                         uint32_t _flags_save_string = ndr->flags;
11416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11417                         if (r->driver_name) {
11418                                 uint32_t _relative_save_offset;
11419                                 _relative_save_offset = ndr->offset;
11420                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11421                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11422                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11423                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11424                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11425                                 ndr->offset = _relative_save_offset;
11426                         }
11427                         ndr->flags = _flags_save_string;
11428                 }
11429                 {
11430                         uint32_t _flags_save_string = ndr->flags;
11431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11432                         if (r->architecture) {
11433                                 uint32_t _relative_save_offset;
11434                                 _relative_save_offset = ndr->offset;
11435                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11436                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11437                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11438                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11439                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11440                                 ndr->offset = _relative_save_offset;
11441                         }
11442                         ndr->flags = _flags_save_string;
11443                 }
11444                 {
11445                         uint32_t _flags_save_string = ndr->flags;
11446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11447                         if (r->driver_path) {
11448                                 uint32_t _relative_save_offset;
11449                                 _relative_save_offset = ndr->offset;
11450                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11451                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11452                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11453                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11454                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11455                                 ndr->offset = _relative_save_offset;
11456                         }
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                         if (r->data_file) {
11463                                 uint32_t _relative_save_offset;
11464                                 _relative_save_offset = ndr->offset;
11465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11466                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11467                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11470                                 ndr->offset = _relative_save_offset;
11471                         }
11472                         ndr->flags = _flags_save_string;
11473                 }
11474                 {
11475                         uint32_t _flags_save_string = ndr->flags;
11476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11477                         if (r->config_file) {
11478                                 uint32_t _relative_save_offset;
11479                                 _relative_save_offset = ndr->offset;
11480                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11481                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11482                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11483                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11484                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11485                                 ndr->offset = _relative_save_offset;
11486                         }
11487                         ndr->flags = _flags_save_string;
11488                 }
11489         }
11490         return NDR_ERR_SUCCESS;
11491 }
11492
11493 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11494 {
11495         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11496         ndr->depth++;
11497         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11498         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11499         ndr->depth++;
11500         if (r->driver_name) {
11501                 ndr_print_string(ndr, "driver_name", r->driver_name);
11502         }
11503         ndr->depth--;
11504         ndr_print_ptr(ndr, "architecture", r->architecture);
11505         ndr->depth++;
11506         if (r->architecture) {
11507                 ndr_print_string(ndr, "architecture", r->architecture);
11508         }
11509         ndr->depth--;
11510         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11511         ndr->depth++;
11512         if (r->driver_path) {
11513                 ndr_print_string(ndr, "driver_path", r->driver_path);
11514         }
11515         ndr->depth--;
11516         ndr_print_ptr(ndr, "data_file", r->data_file);
11517         ndr->depth++;
11518         if (r->data_file) {
11519                 ndr_print_string(ndr, "data_file", r->data_file);
11520         }
11521         ndr->depth--;
11522         ndr_print_ptr(ndr, "config_file", r->config_file);
11523         ndr->depth++;
11524         if (r->config_file) {
11525                 ndr_print_string(ndr, "config_file", r->config_file);
11526         }
11527         ndr->depth--;
11528         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
11529         ndr_print_uint32(ndr, "config_version", r->config_version);
11530         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11531         ndr->depth--;
11532 }
11533
11534 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11535 {
11536         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11537 }
11538
11539 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11540 {
11541         if (ndr_flags & NDR_SCALARS) {
11542                 NDR_CHECK(ndr_push_align(ndr, 8));
11543                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11544                 {
11545                         uint32_t _flags_save_string = ndr->flags;
11546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11547                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11554                         ndr->flags = _flags_save_string;
11555                 }
11556                 {
11557                         uint32_t _flags_save_string = ndr->flags;
11558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11559                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11560                         ndr->flags = _flags_save_string;
11561                 }
11562                 {
11563                         uint32_t _flags_save_string = ndr->flags;
11564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
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                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11572                         ndr->flags = _flags_save_string;
11573                 }
11574                 {
11575                         uint32_t _flags_save_string = ndr->flags;
11576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11578                         ndr->flags = _flags_save_string;
11579                 }
11580                 {
11581                         uint32_t _flags_save_string_array = ndr->flags;
11582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11584                         ndr->flags = _flags_save_string_array;
11585                 }
11586                 {
11587                         uint32_t _flags_save_string = ndr->flags;
11588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11590                         ndr->flags = _flags_save_string;
11591                 }
11592                 {
11593                         uint32_t _flags_save_string = ndr->flags;
11594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11595                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11596                         ndr->flags = _flags_save_string;
11597                 }
11598                 {
11599                         uint32_t _flags_save_string_array = ndr->flags;
11600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11601                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11602                         ndr->flags = _flags_save_string_array;
11603                 }
11604                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11605                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11606                 {
11607                         uint32_t _flags_save_string = ndr->flags;
11608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11610                         ndr->flags = _flags_save_string;
11611                 }
11612                 {
11613                         uint32_t _flags_save_string = ndr->flags;
11614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11615                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11616                         ndr->flags = _flags_save_string;
11617                 }
11618                 {
11619                         uint32_t _flags_save_string = ndr->flags;
11620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11621                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11622                         ndr->flags = _flags_save_string;
11623                 }
11624                 {
11625                         uint32_t _flags_save_string = ndr->flags;
11626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11627                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11628                         ndr->flags = _flags_save_string;
11629                 }
11630         }
11631         if (ndr_flags & NDR_BUFFERS) {
11632                 {
11633                         uint32_t _flags_save_string = ndr->flags;
11634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11635                         if (r->driver_name) {
11636                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11637                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11638                         }
11639                         ndr->flags = _flags_save_string;
11640                 }
11641                 {
11642                         uint32_t _flags_save_string = ndr->flags;
11643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11644                         if (r->architecture) {
11645                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11647                         }
11648                         ndr->flags = _flags_save_string;
11649                 }
11650                 {
11651                         uint32_t _flags_save_string = ndr->flags;
11652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11653                         if (r->driver_path) {
11654                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11655                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11656                         }
11657                         ndr->flags = _flags_save_string;
11658                 }
11659                 {
11660                         uint32_t _flags_save_string = ndr->flags;
11661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11662                         if (r->data_file) {
11663                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11665                         }
11666                         ndr->flags = _flags_save_string;
11667                 }
11668                 {
11669                         uint32_t _flags_save_string = ndr->flags;
11670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11671                         if (r->config_file) {
11672                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11673                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11674                         }
11675                         ndr->flags = _flags_save_string;
11676                 }
11677                 {
11678                         uint32_t _flags_save_string = ndr->flags;
11679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11680                         if (r->help_file) {
11681                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11682                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11683                         }
11684                         ndr->flags = _flags_save_string;
11685                 }
11686                 {
11687                         uint32_t _flags_save_string_array = ndr->flags;
11688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11689                         if (r->dependent_files) {
11690                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11691                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11692                         }
11693                         ndr->flags = _flags_save_string_array;
11694                 }
11695                 {
11696                         uint32_t _flags_save_string = ndr->flags;
11697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11698                         if (r->monitor_name) {
11699                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11700                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11701                         }
11702                         ndr->flags = _flags_save_string;
11703                 }
11704                 {
11705                         uint32_t _flags_save_string = ndr->flags;
11706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11707                         if (r->default_datatype) {
11708                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11710                         }
11711                         ndr->flags = _flags_save_string;
11712                 }
11713                 {
11714                         uint32_t _flags_save_string_array = ndr->flags;
11715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11716                         if (r->previous_names) {
11717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11718                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11719                         }
11720                         ndr->flags = _flags_save_string_array;
11721                 }
11722                 {
11723                         uint32_t _flags_save_string = ndr->flags;
11724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11725                         if (r->manufacturer_name) {
11726                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11727                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11728                         }
11729                         ndr->flags = _flags_save_string;
11730                 }
11731                 {
11732                         uint32_t _flags_save_string = ndr->flags;
11733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11734                         if (r->manufacturer_url) {
11735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11736                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
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                         if (r->hardware_id) {
11744                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11745                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11746                         }
11747                         ndr->flags = _flags_save_string;
11748                 }
11749                 {
11750                         uint32_t _flags_save_string = ndr->flags;
11751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11752                         if (r->provider) {
11753                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11754                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11755                         }
11756                         ndr->flags = _flags_save_string;
11757                 }
11758         }
11759         return NDR_ERR_SUCCESS;
11760 }
11761
11762 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11763 {
11764         uint32_t _ptr_driver_name;
11765         TALLOC_CTX *_mem_save_driver_name_0;
11766         uint32_t _ptr_architecture;
11767         TALLOC_CTX *_mem_save_architecture_0;
11768         uint32_t _ptr_driver_path;
11769         TALLOC_CTX *_mem_save_driver_path_0;
11770         uint32_t _ptr_data_file;
11771         TALLOC_CTX *_mem_save_data_file_0;
11772         uint32_t _ptr_config_file;
11773         TALLOC_CTX *_mem_save_config_file_0;
11774         uint32_t _ptr_help_file;
11775         TALLOC_CTX *_mem_save_help_file_0;
11776         uint32_t _ptr_dependent_files;
11777         TALLOC_CTX *_mem_save_dependent_files_0;
11778         uint32_t _ptr_monitor_name;
11779         TALLOC_CTX *_mem_save_monitor_name_0;
11780         uint32_t _ptr_default_datatype;
11781         TALLOC_CTX *_mem_save_default_datatype_0;
11782         uint32_t _ptr_previous_names;
11783         TALLOC_CTX *_mem_save_previous_names_0;
11784         uint32_t _ptr_manufacturer_name;
11785         TALLOC_CTX *_mem_save_manufacturer_name_0;
11786         uint32_t _ptr_manufacturer_url;
11787         TALLOC_CTX *_mem_save_manufacturer_url_0;
11788         uint32_t _ptr_hardware_id;
11789         TALLOC_CTX *_mem_save_hardware_id_0;
11790         uint32_t _ptr_provider;
11791         TALLOC_CTX *_mem_save_provider_0;
11792         if (ndr_flags & NDR_SCALARS) {
11793                 NDR_CHECK(ndr_pull_align(ndr, 8));
11794                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11795                 {
11796                         uint32_t _flags_save_string = ndr->flags;
11797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11798                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11799                         if (_ptr_driver_name) {
11800                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11801                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11802                         } else {
11803                                 r->driver_name = NULL;
11804                         }
11805                         ndr->flags = _flags_save_string;
11806                 }
11807                 {
11808                         uint32_t _flags_save_string = ndr->flags;
11809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11811                         if (_ptr_architecture) {
11812                                 NDR_PULL_ALLOC(ndr, r->architecture);
11813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11814                         } else {
11815                                 r->architecture = NULL;
11816                         }
11817                         ndr->flags = _flags_save_string;
11818                 }
11819                 {
11820                         uint32_t _flags_save_string = ndr->flags;
11821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11822                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11823                         if (_ptr_driver_path) {
11824                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11825                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11826                         } else {
11827                                 r->driver_path = NULL;
11828                         }
11829                         ndr->flags = _flags_save_string;
11830                 }
11831                 {
11832                         uint32_t _flags_save_string = ndr->flags;
11833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11834                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11835                         if (_ptr_data_file) {
11836                                 NDR_PULL_ALLOC(ndr, r->data_file);
11837                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11838                         } else {
11839                                 r->data_file = NULL;
11840                         }
11841                         ndr->flags = _flags_save_string;
11842                 }
11843                 {
11844                         uint32_t _flags_save_string = ndr->flags;
11845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11847                         if (_ptr_config_file) {
11848                                 NDR_PULL_ALLOC(ndr, r->config_file);
11849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11850                         } else {
11851                                 r->config_file = NULL;
11852                         }
11853                         ndr->flags = _flags_save_string;
11854                 }
11855                 {
11856                         uint32_t _flags_save_string = ndr->flags;
11857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11858                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11859                         if (_ptr_help_file) {
11860                                 NDR_PULL_ALLOC(ndr, r->help_file);
11861                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11862                         } else {
11863                                 r->help_file = NULL;
11864                         }
11865                         ndr->flags = _flags_save_string;
11866                 }
11867                 {
11868                         uint32_t _flags_save_string_array = ndr->flags;
11869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11870                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11871                         if (_ptr_dependent_files) {
11872                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11873                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11874                         } else {
11875                                 r->dependent_files = NULL;
11876                         }
11877                         ndr->flags = _flags_save_string_array;
11878                 }
11879                 {
11880                         uint32_t _flags_save_string = ndr->flags;
11881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11883                         if (_ptr_monitor_name) {
11884                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11886                         } else {
11887                                 r->monitor_name = NULL;
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                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11895                         if (_ptr_default_datatype) {
11896                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11897                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11898                         } else {
11899                                 r->default_datatype = NULL;
11900                         }
11901                         ndr->flags = _flags_save_string;
11902                 }
11903                 {
11904                         uint32_t _flags_save_string_array = ndr->flags;
11905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11906                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11907                         if (_ptr_previous_names) {
11908                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11909                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11910                         } else {
11911                                 r->previous_names = NULL;
11912                         }
11913                         ndr->flags = _flags_save_string_array;
11914                 }
11915                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11916                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11917                 {
11918                         uint32_t _flags_save_string = ndr->flags;
11919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11920                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11921                         if (_ptr_manufacturer_name) {
11922                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11923                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11924                         } else {
11925                                 r->manufacturer_name = NULL;
11926                         }
11927                         ndr->flags = _flags_save_string;
11928                 }
11929                 {
11930                         uint32_t _flags_save_string = ndr->flags;
11931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11932                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11933                         if (_ptr_manufacturer_url) {
11934                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11935                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11936                         } else {
11937                                 r->manufacturer_url = NULL;
11938                         }
11939                         ndr->flags = _flags_save_string;
11940                 }
11941                 {
11942                         uint32_t _flags_save_string = ndr->flags;
11943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11944                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11945                         if (_ptr_hardware_id) {
11946                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11947                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11948                         } else {
11949                                 r->hardware_id = NULL;
11950                         }
11951                         ndr->flags = _flags_save_string;
11952                 }
11953                 {
11954                         uint32_t _flags_save_string = ndr->flags;
11955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11956                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11957                         if (_ptr_provider) {
11958                                 NDR_PULL_ALLOC(ndr, r->provider);
11959                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11960                         } else {
11961                                 r->provider = NULL;
11962                         }
11963                         ndr->flags = _flags_save_string;
11964                 }
11965         }
11966         if (ndr_flags & NDR_BUFFERS) {
11967                 {
11968                         uint32_t _flags_save_string = ndr->flags;
11969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11970                         if (r->driver_name) {
11971                                 uint32_t _relative_save_offset;
11972                                 _relative_save_offset = ndr->offset;
11973                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11974                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11975                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11976                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11977                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11978                                 ndr->offset = _relative_save_offset;
11979                         }
11980                         ndr->flags = _flags_save_string;
11981                 }
11982                 {
11983                         uint32_t _flags_save_string = ndr->flags;
11984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11985                         if (r->architecture) {
11986                                 uint32_t _relative_save_offset;
11987                                 _relative_save_offset = ndr->offset;
11988                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11989                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11990                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11991                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11992                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11993                                 ndr->offset = _relative_save_offset;
11994                         }
11995                         ndr->flags = _flags_save_string;
11996                 }
11997                 {
11998                         uint32_t _flags_save_string = ndr->flags;
11999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12000                         if (r->driver_path) {
12001                                 uint32_t _relative_save_offset;
12002                                 _relative_save_offset = ndr->offset;
12003                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12004                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12005                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12006                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12007                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12008                                 ndr->offset = _relative_save_offset;
12009                         }
12010                         ndr->flags = _flags_save_string;
12011                 }
12012                 {
12013                         uint32_t _flags_save_string = ndr->flags;
12014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12015                         if (r->data_file) {
12016                                 uint32_t _relative_save_offset;
12017                                 _relative_save_offset = ndr->offset;
12018                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12019                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12020                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12021                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12022                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12023                                 ndr->offset = _relative_save_offset;
12024                         }
12025                         ndr->flags = _flags_save_string;
12026                 }
12027                 {
12028                         uint32_t _flags_save_string = ndr->flags;
12029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12030                         if (r->config_file) {
12031                                 uint32_t _relative_save_offset;
12032                                 _relative_save_offset = ndr->offset;
12033                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12034                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12035                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12036                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12037                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12038                                 ndr->offset = _relative_save_offset;
12039                         }
12040                         ndr->flags = _flags_save_string;
12041                 }
12042                 {
12043                         uint32_t _flags_save_string = ndr->flags;
12044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12045                         if (r->help_file) {
12046                                 uint32_t _relative_save_offset;
12047                                 _relative_save_offset = ndr->offset;
12048                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12049                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12050                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12051                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12052                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12053                                 ndr->offset = _relative_save_offset;
12054                         }
12055                         ndr->flags = _flags_save_string;
12056                 }
12057                 {
12058                         uint32_t _flags_save_string_array = ndr->flags;
12059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12060                         if (r->dependent_files) {
12061                                 uint32_t _relative_save_offset;
12062                                 _relative_save_offset = ndr->offset;
12063                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12064                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12065                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12066                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12067                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12068                                 ndr->offset = _relative_save_offset;
12069                         }
12070                         ndr->flags = _flags_save_string_array;
12071                 }
12072                 {
12073                         uint32_t _flags_save_string = ndr->flags;
12074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12075                         if (r->monitor_name) {
12076                                 uint32_t _relative_save_offset;
12077                                 _relative_save_offset = ndr->offset;
12078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12079                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12080                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12083                                 ndr->offset = _relative_save_offset;
12084                         }
12085                         ndr->flags = _flags_save_string;
12086                 }
12087                 {
12088                         uint32_t _flags_save_string = ndr->flags;
12089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12090                         if (r->default_datatype) {
12091                                 uint32_t _relative_save_offset;
12092                                 _relative_save_offset = ndr->offset;
12093                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12094                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12095                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12096                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12097                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12098                                 ndr->offset = _relative_save_offset;
12099                         }
12100                         ndr->flags = _flags_save_string;
12101                 }
12102                 {
12103                         uint32_t _flags_save_string_array = ndr->flags;
12104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12105                         if (r->previous_names) {
12106                                 uint32_t _relative_save_offset;
12107                                 _relative_save_offset = ndr->offset;
12108                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12109                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12110                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12111                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12112                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12113                                 ndr->offset = _relative_save_offset;
12114                         }
12115                         ndr->flags = _flags_save_string_array;
12116                 }
12117                 {
12118                         uint32_t _flags_save_string = ndr->flags;
12119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12120                         if (r->manufacturer_name) {
12121                                 uint32_t _relative_save_offset;
12122                                 _relative_save_offset = ndr->offset;
12123                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12124                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12125                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12126                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12127                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12128                                 ndr->offset = _relative_save_offset;
12129                         }
12130                         ndr->flags = _flags_save_string;
12131                 }
12132                 {
12133                         uint32_t _flags_save_string = ndr->flags;
12134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12135                         if (r->manufacturer_url) {
12136                                 uint32_t _relative_save_offset;
12137                                 _relative_save_offset = ndr->offset;
12138                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12139                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12140                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12141                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12142                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12143                                 ndr->offset = _relative_save_offset;
12144                         }
12145                         ndr->flags = _flags_save_string;
12146                 }
12147                 {
12148                         uint32_t _flags_save_string = ndr->flags;
12149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12150                         if (r->hardware_id) {
12151                                 uint32_t _relative_save_offset;
12152                                 _relative_save_offset = ndr->offset;
12153                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12154                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12155                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12156                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12157                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12158                                 ndr->offset = _relative_save_offset;
12159                         }
12160                         ndr->flags = _flags_save_string;
12161                 }
12162                 {
12163                         uint32_t _flags_save_string = ndr->flags;
12164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12165                         if (r->provider) {
12166                                 uint32_t _relative_save_offset;
12167                                 _relative_save_offset = ndr->offset;
12168                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12169                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12170                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12171                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12172                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12173                                 ndr->offset = _relative_save_offset;
12174                         }
12175                         ndr->flags = _flags_save_string;
12176                 }
12177         }
12178         return NDR_ERR_SUCCESS;
12179 }
12180
12181 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12182 {
12183         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12184         ndr->depth++;
12185         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12186         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12187         ndr->depth++;
12188         if (r->driver_name) {
12189                 ndr_print_string(ndr, "driver_name", r->driver_name);
12190         }
12191         ndr->depth--;
12192         ndr_print_ptr(ndr, "architecture", r->architecture);
12193         ndr->depth++;
12194         if (r->architecture) {
12195                 ndr_print_string(ndr, "architecture", r->architecture);
12196         }
12197         ndr->depth--;
12198         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12199         ndr->depth++;
12200         if (r->driver_path) {
12201                 ndr_print_string(ndr, "driver_path", r->driver_path);
12202         }
12203         ndr->depth--;
12204         ndr_print_ptr(ndr, "data_file", r->data_file);
12205         ndr->depth++;
12206         if (r->data_file) {
12207                 ndr_print_string(ndr, "data_file", r->data_file);
12208         }
12209         ndr->depth--;
12210         ndr_print_ptr(ndr, "config_file", r->config_file);
12211         ndr->depth++;
12212         if (r->config_file) {
12213                 ndr_print_string(ndr, "config_file", r->config_file);
12214         }
12215         ndr->depth--;
12216         ndr_print_ptr(ndr, "help_file", r->help_file);
12217         ndr->depth++;
12218         if (r->help_file) {
12219                 ndr_print_string(ndr, "help_file", r->help_file);
12220         }
12221         ndr->depth--;
12222         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12223         ndr->depth++;
12224         if (r->dependent_files) {
12225                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12226         }
12227         ndr->depth--;
12228         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12229         ndr->depth++;
12230         if (r->monitor_name) {
12231                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12232         }
12233         ndr->depth--;
12234         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12235         ndr->depth++;
12236         if (r->default_datatype) {
12237                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12238         }
12239         ndr->depth--;
12240         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12241         ndr->depth++;
12242         if (r->previous_names) {
12243                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12244         }
12245         ndr->depth--;
12246         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12247         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12248         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12249         ndr->depth++;
12250         if (r->manufacturer_name) {
12251                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12252         }
12253         ndr->depth--;
12254         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12255         ndr->depth++;
12256         if (r->manufacturer_url) {
12257                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12258         }
12259         ndr->depth--;
12260         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12261         ndr->depth++;
12262         if (r->hardware_id) {
12263                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12264         }
12265         ndr->depth--;
12266         ndr_print_ptr(ndr, "provider", r->provider);
12267         ndr->depth++;
12268         if (r->provider) {
12269                 ndr_print_string(ndr, "provider", r->provider);
12270         }
12271         ndr->depth--;
12272         ndr->depth--;
12273 }
12274
12275 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12276 {
12277         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12278 }
12279
12280 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12281 {
12282         if (ndr_flags & NDR_SCALARS) {
12283                 NDR_CHECK(ndr_push_align(ndr, 8));
12284                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12285                 {
12286                         uint32_t _flags_save_string = ndr->flags;
12287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12289                         ndr->flags = _flags_save_string;
12290                 }
12291                 {
12292                         uint32_t _flags_save_string = ndr->flags;
12293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12295                         ndr->flags = _flags_save_string;
12296                 }
12297                 {
12298                         uint32_t _flags_save_string = ndr->flags;
12299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12301                         ndr->flags = _flags_save_string;
12302                 }
12303                 {
12304                         uint32_t _flags_save_string = ndr->flags;
12305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12307                         ndr->flags = _flags_save_string;
12308                 }
12309                 {
12310                         uint32_t _flags_save_string = ndr->flags;
12311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12312                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12313                         ndr->flags = _flags_save_string;
12314                 }
12315                 {
12316                         uint32_t _flags_save_string = ndr->flags;
12317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12319                         ndr->flags = _flags_save_string;
12320                 }
12321                 {
12322                         uint32_t _flags_save_string = ndr->flags;
12323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12325                         ndr->flags = _flags_save_string;
12326                 }
12327                 {
12328                         uint32_t _flags_save_string = ndr->flags;
12329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12330                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12331                         ndr->flags = _flags_save_string;
12332                 }
12333                 {
12334                         uint32_t _flags_save_string_array = ndr->flags;
12335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12336                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12337                         ndr->flags = _flags_save_string_array;
12338                 }
12339                 {
12340                         uint32_t _flags_save_string_array = ndr->flags;
12341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12342                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12343                         ndr->flags = _flags_save_string_array;
12344                 }
12345                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12346                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12347                 {
12348                         uint32_t _flags_save_string = ndr->flags;
12349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12350                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12351                         ndr->flags = _flags_save_string;
12352                 }
12353                 {
12354                         uint32_t _flags_save_string = ndr->flags;
12355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12356                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12357                         ndr->flags = _flags_save_string;
12358                 }
12359                 {
12360                         uint32_t _flags_save_string = ndr->flags;
12361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12362                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12363                         ndr->flags = _flags_save_string;
12364                 }
12365                 {
12366                         uint32_t _flags_save_string = ndr->flags;
12367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12368                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12369                         ndr->flags = _flags_save_string;
12370                 }
12371                 {
12372                         uint32_t _flags_save_string = ndr->flags;
12373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12374                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12375                         ndr->flags = _flags_save_string;
12376                 }
12377                 {
12378                         uint32_t _flags_save_string = ndr->flags;
12379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12380                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12381                         ndr->flags = _flags_save_string;
12382                 }
12383                 {
12384                         uint32_t _flags_save_string_array = ndr->flags;
12385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12386                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12387                         ndr->flags = _flags_save_string_array;
12388                 }
12389                 {
12390                         uint32_t _flags_save_string = ndr->flags;
12391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12392                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12393                         ndr->flags = _flags_save_string;
12394                 }
12395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12396                 {
12397                         uint32_t _flags_save_string_array = ndr->flags;
12398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12399                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12400                         ndr->flags = _flags_save_string_array;
12401                 }
12402                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12403                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12404         }
12405         if (ndr_flags & NDR_BUFFERS) {
12406                 {
12407                         uint32_t _flags_save_string = ndr->flags;
12408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12409                         if (r->driver_name) {
12410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12412                         }
12413                         ndr->flags = _flags_save_string;
12414                 }
12415                 {
12416                         uint32_t _flags_save_string = ndr->flags;
12417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12418                         if (r->architecture) {
12419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12421                         }
12422                         ndr->flags = _flags_save_string;
12423                 }
12424                 {
12425                         uint32_t _flags_save_string = ndr->flags;
12426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12427                         if (r->driver_path) {
12428                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12429                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12430                         }
12431                         ndr->flags = _flags_save_string;
12432                 }
12433                 {
12434                         uint32_t _flags_save_string = ndr->flags;
12435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12436                         if (r->data_file) {
12437                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12438                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12439                         }
12440                         ndr->flags = _flags_save_string;
12441                 }
12442                 {
12443                         uint32_t _flags_save_string = ndr->flags;
12444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12445                         if (r->config_file) {
12446                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12447                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12448                         }
12449                         ndr->flags = _flags_save_string;
12450                 }
12451                 {
12452                         uint32_t _flags_save_string = ndr->flags;
12453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12454                         if (r->help_file) {
12455                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12456                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12457                         }
12458                         ndr->flags = _flags_save_string;
12459                 }
12460                 {
12461                         uint32_t _flags_save_string = ndr->flags;
12462                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12463                         if (r->monitor_name) {
12464                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12465                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12466                         }
12467                         ndr->flags = _flags_save_string;
12468                 }
12469                 {
12470                         uint32_t _flags_save_string = ndr->flags;
12471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12472                         if (r->default_datatype) {
12473                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12474                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12475                         }
12476                         ndr->flags = _flags_save_string;
12477                 }
12478                 {
12479                         uint32_t _flags_save_string_array = ndr->flags;
12480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12481                         if (r->dependent_files) {
12482                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12483                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12484                         }
12485                         ndr->flags = _flags_save_string_array;
12486                 }
12487                 {
12488                         uint32_t _flags_save_string_array = ndr->flags;
12489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12490                         if (r->previous_names) {
12491                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12492                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12493                         }
12494                         ndr->flags = _flags_save_string_array;
12495                 }
12496                 {
12497                         uint32_t _flags_save_string = ndr->flags;
12498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12499                         if (r->manufacturer_name) {
12500                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12501                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12502                         }
12503                         ndr->flags = _flags_save_string;
12504                 }
12505                 {
12506                         uint32_t _flags_save_string = ndr->flags;
12507                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12508                         if (r->manufacturer_url) {
12509                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12510                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12511                         }
12512                         ndr->flags = _flags_save_string;
12513                 }
12514                 {
12515                         uint32_t _flags_save_string = ndr->flags;
12516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12517                         if (r->hardware_id) {
12518                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12519                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12520                         }
12521                         ndr->flags = _flags_save_string;
12522                 }
12523                 {
12524                         uint32_t _flags_save_string = ndr->flags;
12525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12526                         if (r->provider) {
12527                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12528                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12529                         }
12530                         ndr->flags = _flags_save_string;
12531                 }
12532                 {
12533                         uint32_t _flags_save_string = ndr->flags;
12534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12535                         if (r->print_processor) {
12536                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12537                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12538                         }
12539                         ndr->flags = _flags_save_string;
12540                 }
12541                 {
12542                         uint32_t _flags_save_string = ndr->flags;
12543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12544                         if (r->vendor_setup) {
12545                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12546                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12547                         }
12548                         ndr->flags = _flags_save_string;
12549                 }
12550                 {
12551                         uint32_t _flags_save_string_array = ndr->flags;
12552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12553                         if (r->color_profiles) {
12554                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12555                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12556                         }
12557                         ndr->flags = _flags_save_string_array;
12558                 }
12559                 {
12560                         uint32_t _flags_save_string = ndr->flags;
12561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12562                         if (r->inf_path) {
12563                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12564                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12565                         }
12566                         ndr->flags = _flags_save_string;
12567                 }
12568                 {
12569                         uint32_t _flags_save_string_array = ndr->flags;
12570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12571                         if (r->core_driver_dependencies) {
12572                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12573                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12574                         }
12575                         ndr->flags = _flags_save_string_array;
12576                 }
12577         }
12578         return NDR_ERR_SUCCESS;
12579 }
12580
12581 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12582 {
12583         uint32_t _ptr_driver_name;
12584         TALLOC_CTX *_mem_save_driver_name_0;
12585         uint32_t _ptr_architecture;
12586         TALLOC_CTX *_mem_save_architecture_0;
12587         uint32_t _ptr_driver_path;
12588         TALLOC_CTX *_mem_save_driver_path_0;
12589         uint32_t _ptr_data_file;
12590         TALLOC_CTX *_mem_save_data_file_0;
12591         uint32_t _ptr_config_file;
12592         TALLOC_CTX *_mem_save_config_file_0;
12593         uint32_t _ptr_help_file;
12594         TALLOC_CTX *_mem_save_help_file_0;
12595         uint32_t _ptr_monitor_name;
12596         TALLOC_CTX *_mem_save_monitor_name_0;
12597         uint32_t _ptr_default_datatype;
12598         TALLOC_CTX *_mem_save_default_datatype_0;
12599         uint32_t _ptr_dependent_files;
12600         TALLOC_CTX *_mem_save_dependent_files_0;
12601         uint32_t _ptr_previous_names;
12602         TALLOC_CTX *_mem_save_previous_names_0;
12603         uint32_t _ptr_manufacturer_name;
12604         TALLOC_CTX *_mem_save_manufacturer_name_0;
12605         uint32_t _ptr_manufacturer_url;
12606         TALLOC_CTX *_mem_save_manufacturer_url_0;
12607         uint32_t _ptr_hardware_id;
12608         TALLOC_CTX *_mem_save_hardware_id_0;
12609         uint32_t _ptr_provider;
12610         TALLOC_CTX *_mem_save_provider_0;
12611         uint32_t _ptr_print_processor;
12612         TALLOC_CTX *_mem_save_print_processor_0;
12613         uint32_t _ptr_vendor_setup;
12614         TALLOC_CTX *_mem_save_vendor_setup_0;
12615         uint32_t _ptr_color_profiles;
12616         TALLOC_CTX *_mem_save_color_profiles_0;
12617         uint32_t _ptr_inf_path;
12618         TALLOC_CTX *_mem_save_inf_path_0;
12619         uint32_t _ptr_core_driver_dependencies;
12620         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12621         if (ndr_flags & NDR_SCALARS) {
12622                 NDR_CHECK(ndr_pull_align(ndr, 8));
12623                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12624                 {
12625                         uint32_t _flags_save_string = ndr->flags;
12626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12627                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12628                         if (_ptr_driver_name) {
12629                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12630                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12631                         } else {
12632                                 r->driver_name = NULL;
12633                         }
12634                         ndr->flags = _flags_save_string;
12635                 }
12636                 {
12637                         uint32_t _flags_save_string = ndr->flags;
12638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12639                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12640                         if (_ptr_architecture) {
12641                                 NDR_PULL_ALLOC(ndr, r->architecture);
12642                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12643                         } else {
12644                                 r->architecture = NULL;
12645                         }
12646                         ndr->flags = _flags_save_string;
12647                 }
12648                 {
12649                         uint32_t _flags_save_string = ndr->flags;
12650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12651                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12652                         if (_ptr_driver_path) {
12653                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12654                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12655                         } else {
12656                                 r->driver_path = NULL;
12657                         }
12658                         ndr->flags = _flags_save_string;
12659                 }
12660                 {
12661                         uint32_t _flags_save_string = ndr->flags;
12662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12663                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12664                         if (_ptr_data_file) {
12665                                 NDR_PULL_ALLOC(ndr, r->data_file);
12666                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12667                         } else {
12668                                 r->data_file = NULL;
12669                         }
12670                         ndr->flags = _flags_save_string;
12671                 }
12672                 {
12673                         uint32_t _flags_save_string = ndr->flags;
12674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12675                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12676                         if (_ptr_config_file) {
12677                                 NDR_PULL_ALLOC(ndr, r->config_file);
12678                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12679                         } else {
12680                                 r->config_file = NULL;
12681                         }
12682                         ndr->flags = _flags_save_string;
12683                 }
12684                 {
12685                         uint32_t _flags_save_string = ndr->flags;
12686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12687                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12688                         if (_ptr_help_file) {
12689                                 NDR_PULL_ALLOC(ndr, r->help_file);
12690                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12691                         } else {
12692                                 r->help_file = NULL;
12693                         }
12694                         ndr->flags = _flags_save_string;
12695                 }
12696                 {
12697                         uint32_t _flags_save_string = ndr->flags;
12698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12699                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12700                         if (_ptr_monitor_name) {
12701                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12702                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12703                         } else {
12704                                 r->monitor_name = NULL;
12705                         }
12706                         ndr->flags = _flags_save_string;
12707                 }
12708                 {
12709                         uint32_t _flags_save_string = ndr->flags;
12710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12711                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12712                         if (_ptr_default_datatype) {
12713                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12714                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12715                         } else {
12716                                 r->default_datatype = NULL;
12717                         }
12718                         ndr->flags = _flags_save_string;
12719                 }
12720                 {
12721                         uint32_t _flags_save_string_array = ndr->flags;
12722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12723                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12724                         if (_ptr_dependent_files) {
12725                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12726                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12727                         } else {
12728                                 r->dependent_files = NULL;
12729                         }
12730                         ndr->flags = _flags_save_string_array;
12731                 }
12732                 {
12733                         uint32_t _flags_save_string_array = ndr->flags;
12734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12735                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12736                         if (_ptr_previous_names) {
12737                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12738                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12739                         } else {
12740                                 r->previous_names = NULL;
12741                         }
12742                         ndr->flags = _flags_save_string_array;
12743                 }
12744                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12745                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12746                 {
12747                         uint32_t _flags_save_string = ndr->flags;
12748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12749                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12750                         if (_ptr_manufacturer_name) {
12751                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12752                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12753                         } else {
12754                                 r->manufacturer_name = NULL;
12755                         }
12756                         ndr->flags = _flags_save_string;
12757                 }
12758                 {
12759                         uint32_t _flags_save_string = ndr->flags;
12760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12761                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12762                         if (_ptr_manufacturer_url) {
12763                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12764                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12765                         } else {
12766                                 r->manufacturer_url = NULL;
12767                         }
12768                         ndr->flags = _flags_save_string;
12769                 }
12770                 {
12771                         uint32_t _flags_save_string = ndr->flags;
12772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12773                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12774                         if (_ptr_hardware_id) {
12775                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12776                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12777                         } else {
12778                                 r->hardware_id = NULL;
12779                         }
12780                         ndr->flags = _flags_save_string;
12781                 }
12782                 {
12783                         uint32_t _flags_save_string = ndr->flags;
12784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12785                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12786                         if (_ptr_provider) {
12787                                 NDR_PULL_ALLOC(ndr, r->provider);
12788                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12789                         } else {
12790                                 r->provider = NULL;
12791                         }
12792                         ndr->flags = _flags_save_string;
12793                 }
12794                 {
12795                         uint32_t _flags_save_string = ndr->flags;
12796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12797                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12798                         if (_ptr_print_processor) {
12799                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12800                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12801                         } else {
12802                                 r->print_processor = NULL;
12803                         }
12804                         ndr->flags = _flags_save_string;
12805                 }
12806                 {
12807                         uint32_t _flags_save_string = ndr->flags;
12808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12809                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12810                         if (_ptr_vendor_setup) {
12811                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12812                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12813                         } else {
12814                                 r->vendor_setup = NULL;
12815                         }
12816                         ndr->flags = _flags_save_string;
12817                 }
12818                 {
12819                         uint32_t _flags_save_string_array = ndr->flags;
12820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12821                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12822                         if (_ptr_color_profiles) {
12823                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12824                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12825                         } else {
12826                                 r->color_profiles = NULL;
12827                         }
12828                         ndr->flags = _flags_save_string_array;
12829                 }
12830                 {
12831                         uint32_t _flags_save_string = ndr->flags;
12832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12833                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12834                         if (_ptr_inf_path) {
12835                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12836                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12837                         } else {
12838                                 r->inf_path = NULL;
12839                         }
12840                         ndr->flags = _flags_save_string;
12841                 }
12842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12843                 {
12844                         uint32_t _flags_save_string_array = ndr->flags;
12845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12847                         if (_ptr_core_driver_dependencies) {
12848                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12850                         } else {
12851                                 r->core_driver_dependencies = NULL;
12852                         }
12853                         ndr->flags = _flags_save_string_array;
12854                 }
12855                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12856                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12857         }
12858         if (ndr_flags & NDR_BUFFERS) {
12859                 {
12860                         uint32_t _flags_save_string = ndr->flags;
12861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12862                         if (r->driver_name) {
12863                                 uint32_t _relative_save_offset;
12864                                 _relative_save_offset = ndr->offset;
12865                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12866                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12867                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12868                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12869                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12870                                 ndr->offset = _relative_save_offset;
12871                         }
12872                         ndr->flags = _flags_save_string;
12873                 }
12874                 {
12875                         uint32_t _flags_save_string = ndr->flags;
12876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12877                         if (r->architecture) {
12878                                 uint32_t _relative_save_offset;
12879                                 _relative_save_offset = ndr->offset;
12880                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12881                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12882                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12883                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12884                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12885                                 ndr->offset = _relative_save_offset;
12886                         }
12887                         ndr->flags = _flags_save_string;
12888                 }
12889                 {
12890                         uint32_t _flags_save_string = ndr->flags;
12891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12892                         if (r->driver_path) {
12893                                 uint32_t _relative_save_offset;
12894                                 _relative_save_offset = ndr->offset;
12895                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12896                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12897                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12898                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12899                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12900                                 ndr->offset = _relative_save_offset;
12901                         }
12902                         ndr->flags = _flags_save_string;
12903                 }
12904                 {
12905                         uint32_t _flags_save_string = ndr->flags;
12906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12907                         if (r->data_file) {
12908                                 uint32_t _relative_save_offset;
12909                                 _relative_save_offset = ndr->offset;
12910                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12911                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12912                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12913                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12914                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12915                                 ndr->offset = _relative_save_offset;
12916                         }
12917                         ndr->flags = _flags_save_string;
12918                 }
12919                 {
12920                         uint32_t _flags_save_string = ndr->flags;
12921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12922                         if (r->config_file) {
12923                                 uint32_t _relative_save_offset;
12924                                 _relative_save_offset = ndr->offset;
12925                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12926                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12927                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12928                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12929                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12930                                 ndr->offset = _relative_save_offset;
12931                         }
12932                         ndr->flags = _flags_save_string;
12933                 }
12934                 {
12935                         uint32_t _flags_save_string = ndr->flags;
12936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12937                         if (r->help_file) {
12938                                 uint32_t _relative_save_offset;
12939                                 _relative_save_offset = ndr->offset;
12940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12941                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12942                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12945                                 ndr->offset = _relative_save_offset;
12946                         }
12947                         ndr->flags = _flags_save_string;
12948                 }
12949                 {
12950                         uint32_t _flags_save_string = ndr->flags;
12951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12952                         if (r->monitor_name) {
12953                                 uint32_t _relative_save_offset;
12954                                 _relative_save_offset = ndr->offset;
12955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12956                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12957                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12958                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12959                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12960                                 ndr->offset = _relative_save_offset;
12961                         }
12962                         ndr->flags = _flags_save_string;
12963                 }
12964                 {
12965                         uint32_t _flags_save_string = ndr->flags;
12966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12967                         if (r->default_datatype) {
12968                                 uint32_t _relative_save_offset;
12969                                 _relative_save_offset = ndr->offset;
12970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12971                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12972                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12975                                 ndr->offset = _relative_save_offset;
12976                         }
12977                         ndr->flags = _flags_save_string;
12978                 }
12979                 {
12980                         uint32_t _flags_save_string_array = ndr->flags;
12981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12982                         if (r->dependent_files) {
12983                                 uint32_t _relative_save_offset;
12984                                 _relative_save_offset = ndr->offset;
12985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12986                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12987                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12988                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12990                                 ndr->offset = _relative_save_offset;
12991                         }
12992                         ndr->flags = _flags_save_string_array;
12993                 }
12994                 {
12995                         uint32_t _flags_save_string_array = ndr->flags;
12996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12997                         if (r->previous_names) {
12998                                 uint32_t _relative_save_offset;
12999                                 _relative_save_offset = ndr->offset;
13000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13001                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13002                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13003                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13005                                 ndr->offset = _relative_save_offset;
13006                         }
13007                         ndr->flags = _flags_save_string_array;
13008                 }
13009                 {
13010                         uint32_t _flags_save_string = ndr->flags;
13011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13012                         if (r->manufacturer_name) {
13013                                 uint32_t _relative_save_offset;
13014                                 _relative_save_offset = ndr->offset;
13015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13016                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13017                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13020                                 ndr->offset = _relative_save_offset;
13021                         }
13022                         ndr->flags = _flags_save_string;
13023                 }
13024                 {
13025                         uint32_t _flags_save_string = ndr->flags;
13026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13027                         if (r->manufacturer_url) {
13028                                 uint32_t _relative_save_offset;
13029                                 _relative_save_offset = ndr->offset;
13030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13031                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13032                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13035                                 ndr->offset = _relative_save_offset;
13036                         }
13037                         ndr->flags = _flags_save_string;
13038                 }
13039                 {
13040                         uint32_t _flags_save_string = ndr->flags;
13041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13042                         if (r->hardware_id) {
13043                                 uint32_t _relative_save_offset;
13044                                 _relative_save_offset = ndr->offset;
13045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13046                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13047                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13050                                 ndr->offset = _relative_save_offset;
13051                         }
13052                         ndr->flags = _flags_save_string;
13053                 }
13054                 {
13055                         uint32_t _flags_save_string = ndr->flags;
13056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13057                         if (r->provider) {
13058                                 uint32_t _relative_save_offset;
13059                                 _relative_save_offset = ndr->offset;
13060                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13061                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13062                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13063                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13064                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13065                                 ndr->offset = _relative_save_offset;
13066                         }
13067                         ndr->flags = _flags_save_string;
13068                 }
13069                 {
13070                         uint32_t _flags_save_string = ndr->flags;
13071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13072                         if (r->print_processor) {
13073                                 uint32_t _relative_save_offset;
13074                                 _relative_save_offset = ndr->offset;
13075                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13076                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13077                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13078                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13079                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13080                                 ndr->offset = _relative_save_offset;
13081                         }
13082                         ndr->flags = _flags_save_string;
13083                 }
13084                 {
13085                         uint32_t _flags_save_string = ndr->flags;
13086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13087                         if (r->vendor_setup) {
13088                                 uint32_t _relative_save_offset;
13089                                 _relative_save_offset = ndr->offset;
13090                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13091                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13092                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13093                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13094                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13095                                 ndr->offset = _relative_save_offset;
13096                         }
13097                         ndr->flags = _flags_save_string;
13098                 }
13099                 {
13100                         uint32_t _flags_save_string_array = ndr->flags;
13101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13102                         if (r->color_profiles) {
13103                                 uint32_t _relative_save_offset;
13104                                 _relative_save_offset = ndr->offset;
13105                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13106                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13107                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13108                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13109                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13110                                 ndr->offset = _relative_save_offset;
13111                         }
13112                         ndr->flags = _flags_save_string_array;
13113                 }
13114                 {
13115                         uint32_t _flags_save_string = ndr->flags;
13116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13117                         if (r->inf_path) {
13118                                 uint32_t _relative_save_offset;
13119                                 _relative_save_offset = ndr->offset;
13120                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13121                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13122                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13123                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13124                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13125                                 ndr->offset = _relative_save_offset;
13126                         }
13127                         ndr->flags = _flags_save_string;
13128                 }
13129                 {
13130                         uint32_t _flags_save_string_array = ndr->flags;
13131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13132                         if (r->core_driver_dependencies) {
13133                                 uint32_t _relative_save_offset;
13134                                 _relative_save_offset = ndr->offset;
13135                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13136                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13137                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13138                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13139                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13140                                 ndr->offset = _relative_save_offset;
13141                         }
13142                         ndr->flags = _flags_save_string_array;
13143                 }
13144         }
13145         return NDR_ERR_SUCCESS;
13146 }
13147
13148 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13149 {
13150         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13151         ndr->depth++;
13152         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13153         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13154         ndr->depth++;
13155         if (r->driver_name) {
13156                 ndr_print_string(ndr, "driver_name", r->driver_name);
13157         }
13158         ndr->depth--;
13159         ndr_print_ptr(ndr, "architecture", r->architecture);
13160         ndr->depth++;
13161         if (r->architecture) {
13162                 ndr_print_string(ndr, "architecture", r->architecture);
13163         }
13164         ndr->depth--;
13165         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13166         ndr->depth++;
13167         if (r->driver_path) {
13168                 ndr_print_string(ndr, "driver_path", r->driver_path);
13169         }
13170         ndr->depth--;
13171         ndr_print_ptr(ndr, "data_file", r->data_file);
13172         ndr->depth++;
13173         if (r->data_file) {
13174                 ndr_print_string(ndr, "data_file", r->data_file);
13175         }
13176         ndr->depth--;
13177         ndr_print_ptr(ndr, "config_file", r->config_file);
13178         ndr->depth++;
13179         if (r->config_file) {
13180                 ndr_print_string(ndr, "config_file", r->config_file);
13181         }
13182         ndr->depth--;
13183         ndr_print_ptr(ndr, "help_file", r->help_file);
13184         ndr->depth++;
13185         if (r->help_file) {
13186                 ndr_print_string(ndr, "help_file", r->help_file);
13187         }
13188         ndr->depth--;
13189         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13190         ndr->depth++;
13191         if (r->monitor_name) {
13192                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13193         }
13194         ndr->depth--;
13195         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13196         ndr->depth++;
13197         if (r->default_datatype) {
13198                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13199         }
13200         ndr->depth--;
13201         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13202         ndr->depth++;
13203         if (r->dependent_files) {
13204                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13205         }
13206         ndr->depth--;
13207         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13208         ndr->depth++;
13209         if (r->previous_names) {
13210                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13211         }
13212         ndr->depth--;
13213         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13214         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13215         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13216         ndr->depth++;
13217         if (r->manufacturer_name) {
13218                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13219         }
13220         ndr->depth--;
13221         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13222         ndr->depth++;
13223         if (r->manufacturer_url) {
13224                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13225         }
13226         ndr->depth--;
13227         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13228         ndr->depth++;
13229         if (r->hardware_id) {
13230                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13231         }
13232         ndr->depth--;
13233         ndr_print_ptr(ndr, "provider", r->provider);
13234         ndr->depth++;
13235         if (r->provider) {
13236                 ndr_print_string(ndr, "provider", r->provider);
13237         }
13238         ndr->depth--;
13239         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13240         ndr->depth++;
13241         if (r->print_processor) {
13242                 ndr_print_string(ndr, "print_processor", r->print_processor);
13243         }
13244         ndr->depth--;
13245         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13246         ndr->depth++;
13247         if (r->vendor_setup) {
13248                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13249         }
13250         ndr->depth--;
13251         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13252         ndr->depth++;
13253         if (r->color_profiles) {
13254                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13255         }
13256         ndr->depth--;
13257         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13258         ndr->depth++;
13259         if (r->inf_path) {
13260                 ndr_print_string(ndr, "inf_path", r->inf_path);
13261         }
13262         ndr->depth--;
13263         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13264         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13265         ndr->depth++;
13266         if (r->core_driver_dependencies) {
13267                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13268         }
13269         ndr->depth--;
13270         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13271         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13272         ndr->depth--;
13273 }
13274
13275 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13276 {
13277         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13278 }
13279
13280 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13281 {
13282         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13283         return NDR_ERR_SUCCESS;
13284 }
13285
13286 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13287 {
13288         uint32_t v;
13289         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13290         *r = v;
13291         return NDR_ERR_SUCCESS;
13292 }
13293
13294 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13295 {
13296         const char *val = NULL;
13297
13298         switch (r) {
13299                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13300                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13301                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13302                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13303                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13304         }
13305         ndr_print_enum(ndr, name, "ENUM", val, r);
13306 }
13307
13308 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13309 {
13310         if (ndr_flags & NDR_SCALARS) {
13311                 NDR_CHECK(ndr_push_align(ndr, 4));
13312                 {
13313                         uint32_t _flags_save_string = ndr->flags;
13314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13315                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13316                         ndr->flags = _flags_save_string;
13317                 }
13318                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13320         }
13321         if (ndr_flags & NDR_BUFFERS) {
13322                 {
13323                         uint32_t _flags_save_string = ndr->flags;
13324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13325                         if (r->file_name) {
13326                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13327                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13328                         }
13329                         ndr->flags = _flags_save_string;
13330                 }
13331         }
13332         return NDR_ERR_SUCCESS;
13333 }
13334
13335 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13336 {
13337         uint32_t _ptr_file_name;
13338         TALLOC_CTX *_mem_save_file_name_0;
13339         if (ndr_flags & NDR_SCALARS) {
13340                 NDR_CHECK(ndr_pull_align(ndr, 4));
13341                 {
13342                         uint32_t _flags_save_string = ndr->flags;
13343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13344                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13345                         if (_ptr_file_name) {
13346                                 NDR_PULL_ALLOC(ndr, r->file_name);
13347                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13348                         } else {
13349                                 r->file_name = NULL;
13350                         }
13351                         ndr->flags = _flags_save_string;
13352                 }
13353                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13355         }
13356         if (ndr_flags & NDR_BUFFERS) {
13357                 {
13358                         uint32_t _flags_save_string = ndr->flags;
13359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13360                         if (r->file_name) {
13361                                 uint32_t _relative_save_offset;
13362                                 _relative_save_offset = ndr->offset;
13363                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13364                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13365                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13366                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13367                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13368                                 ndr->offset = _relative_save_offset;
13369                         }
13370                         ndr->flags = _flags_save_string;
13371                 }
13372         }
13373         return NDR_ERR_SUCCESS;
13374 }
13375
13376 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13377 {
13378         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13379         ndr->depth++;
13380         ndr_print_ptr(ndr, "file_name", r->file_name);
13381         ndr->depth++;
13382         if (r->file_name) {
13383                 ndr_print_string(ndr, "file_name", r->file_name);
13384         }
13385         ndr->depth--;
13386         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13387         ndr_print_uint32(ndr, "file_version", r->file_version);
13388         ndr->depth--;
13389 }
13390
13391 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13392 {
13393         uint32_t cntr_file_info_1;
13394         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13395         ndr->depth++;
13396         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13397         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13398         ndr->depth++;
13399         if (r->driver_name) {
13400                 ndr_print_string(ndr, "driver_name", r->driver_name);
13401         }
13402         ndr->depth--;
13403         ndr_print_ptr(ndr, "architecture", r->architecture);
13404         ndr->depth++;
13405         if (r->architecture) {
13406                 ndr_print_string(ndr, "architecture", r->architecture);
13407         }
13408         ndr->depth--;
13409         ndr_print_ptr(ndr, "file_info", r->file_info);
13410         ndr->depth++;
13411         if (r->file_info) {
13412                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13413                 ndr->depth++;
13414                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13415                         char *idx_1=NULL;
13416                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13417                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13418                                 free(idx_1);
13419                         }
13420                 }
13421                 ndr->depth--;
13422         }
13423         ndr->depth--;
13424         ndr_print_uint32(ndr, "file_count", r->file_count);
13425         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13426         ndr->depth++;
13427         if (r->monitor_name) {
13428                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13429         }
13430         ndr->depth--;
13431         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13432         ndr->depth++;
13433         if (r->default_datatype) {
13434                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13435         }
13436         ndr->depth--;
13437         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13438         ndr->depth++;
13439         if (r->previous_names) {
13440                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13441         }
13442         ndr->depth--;
13443         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13444         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13445         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13446         ndr->depth++;
13447         if (r->manufacturer_name) {
13448                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13449         }
13450         ndr->depth--;
13451         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13452         ndr->depth++;
13453         if (r->manufacturer_url) {
13454                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13455         }
13456         ndr->depth--;
13457         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13458         ndr->depth++;
13459         if (r->hardware_id) {
13460                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13461         }
13462         ndr->depth--;
13463         ndr_print_ptr(ndr, "provider", r->provider);
13464         ndr->depth++;
13465         if (r->provider) {
13466                 ndr_print_string(ndr, "provider", r->provider);
13467         }
13468         ndr->depth--;
13469         ndr->depth--;
13470 }
13471
13472 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13473 {
13474         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13475 }
13476
13477 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13478 {
13479         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13480         if (ndr_flags & NDR_SCALARS) {
13481                 int level = ndr_push_get_switch_value(ndr, r);
13482                 switch (level) {
13483                         case 1: {
13484                                 NDR_CHECK(ndr_push_align(ndr, 4));
13485                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13486                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13487                         break; }
13488
13489                         case 2: {
13490                                 NDR_CHECK(ndr_push_align(ndr, 4));
13491                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13492                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13493                         break; }
13494
13495                         case 3: {
13496                                 NDR_CHECK(ndr_push_align(ndr, 4));
13497                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13498                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13499                         break; }
13500
13501                         case 4: {
13502                                 NDR_CHECK(ndr_push_align(ndr, 4));
13503                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13504                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13505                         break; }
13506
13507                         case 5: {
13508                                 NDR_CHECK(ndr_push_align(ndr, 4));
13509                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13510                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13511                         break; }
13512
13513                         case 6: {
13514                                 NDR_CHECK(ndr_push_align(ndr, 8));
13515                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13516                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13517                         break; }
13518
13519                         case 8: {
13520                                 NDR_CHECK(ndr_push_align(ndr, 8));
13521                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13522                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13523                         break; }
13524
13525                         case 101: {
13526                                 NDR_CHECK(ndr_push_align(ndr, 8));
13527                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13528                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13529                         break; }
13530
13531                         default: {
13532                         break; }
13533
13534                 }
13535         }
13536         if (ndr_flags & NDR_BUFFERS) {
13537                 int level = ndr_push_get_switch_value(ndr, r);
13538                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13539                 switch (level) {
13540                         case 1:
13541                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13542                         break;
13543
13544                         case 2:
13545                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13546                         break;
13547
13548                         case 3:
13549                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13550                         break;
13551
13552                         case 4:
13553                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13554                         break;
13555
13556                         case 5:
13557                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13558                         break;
13559
13560                         case 6:
13561                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13562                         break;
13563
13564                         case 8:
13565                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13566                         break;
13567
13568                         case 101:
13569                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13570                         break;
13571
13572                         default:
13573                         break;
13574
13575                 }
13576         }
13577         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13578         return NDR_ERR_SUCCESS;
13579 }
13580
13581 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13582 {
13583         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13584         int level;
13585         level = ndr_pull_get_switch_value(ndr, r);
13586         if (ndr_flags & NDR_SCALARS) {
13587                 switch (level) {
13588                         case 1: {
13589                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13590                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13591                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13592                         break; }
13593
13594                         case 2: {
13595                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13596                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13597                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13598                         break; }
13599
13600                         case 3: {
13601                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13602                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13603                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13604                         break; }
13605
13606                         case 4: {
13607                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13608                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13609                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13610                         break; }
13611
13612                         case 5: {
13613                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13614                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13615                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13616                         break; }
13617
13618                         case 6: {
13619                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13620                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13621                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13622                         break; }
13623
13624                         case 8: {
13625                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13626                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13627                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13628                         break; }
13629
13630                         case 101: {
13631                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13632                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13633                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13634                         break; }
13635
13636                         default: {
13637                         break; }
13638
13639                 }
13640         }
13641         if (ndr_flags & NDR_BUFFERS) {
13642                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13643                 switch (level) {
13644                         case 1:
13645                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13646                         break;
13647
13648                         case 2:
13649                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13650                         break;
13651
13652                         case 3:
13653                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13654                         break;
13655
13656                         case 4:
13657                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13658                         break;
13659
13660                         case 5:
13661                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13662                         break;
13663
13664                         case 6:
13665                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13666                         break;
13667
13668                         case 8:
13669                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13670                         break;
13671
13672                         case 101:
13673                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13674                         break;
13675
13676                         default:
13677                         break;
13678
13679                 }
13680         }
13681         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13682         return NDR_ERR_SUCCESS;
13683 }
13684
13685 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13686 {
13687         int level;
13688         level = ndr_print_get_switch_value(ndr, r);
13689         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13690         switch (level) {
13691                 case 1:
13692                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13693                 break;
13694
13695                 case 2:
13696                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13697                 break;
13698
13699                 case 3:
13700                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13701                 break;
13702
13703                 case 4:
13704                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13705                 break;
13706
13707                 case 5:
13708                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13709                 break;
13710
13711                 case 6:
13712                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13713                 break;
13714
13715                 case 8:
13716                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13717                 break;
13718
13719                 case 101:
13720                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13721                 break;
13722
13723                 default:
13724                 break;
13725
13726         }
13727 }
13728
13729 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13730 {
13731         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
13732 }
13733
13734 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13735 {
13736         if (ndr_flags & NDR_SCALARS) {
13737                 NDR_CHECK(ndr_push_align(ndr, 4));
13738                 {
13739                         uint32_t _flags_save_string = ndr->flags;
13740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13741                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13742                         ndr->flags = _flags_save_string;
13743                 }
13744         }
13745         if (ndr_flags & NDR_BUFFERS) {
13746         }
13747         return NDR_ERR_SUCCESS;
13748 }
13749
13750 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13751 {
13752         if (ndr_flags & NDR_SCALARS) {
13753                 NDR_CHECK(ndr_pull_align(ndr, 4));
13754                 {
13755                         uint32_t _flags_save_string = ndr->flags;
13756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13757                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13758                         ndr->flags = _flags_save_string;
13759                 }
13760         }
13761         if (ndr_flags & NDR_BUFFERS) {
13762         }
13763         return NDR_ERR_SUCCESS;
13764 }
13765
13766 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13767 {
13768         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13769         ndr->depth++;
13770         ndr_print_string(ndr, "directory_name", r->directory_name);
13771         ndr->depth--;
13772 }
13773
13774 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13775 {
13776         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13777 }
13778
13779 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13780 {
13781         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13782         if (ndr_flags & NDR_SCALARS) {
13783                 int level = ndr_push_get_switch_value(ndr, r);
13784                 switch (level) {
13785                         case 1: {
13786                                 NDR_CHECK(ndr_push_align(ndr, 4));
13787                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13788                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13789                         break; }
13790
13791                         default: {
13792                                 NDR_CHECK(ndr_push_align(ndr, 4));
13793                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13794                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13795                         break; }
13796
13797                 }
13798         }
13799         if (ndr_flags & NDR_BUFFERS) {
13800                 int level = ndr_push_get_switch_value(ndr, r);
13801                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13802                 switch (level) {
13803                         case 1:
13804                         break;
13805
13806                         default:
13807                         break;
13808
13809                 }
13810         }
13811         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13812         return NDR_ERR_SUCCESS;
13813 }
13814
13815 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13816 {
13817         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13818         int level;
13819         level = ndr_pull_get_switch_value(ndr, r);
13820         if (ndr_flags & NDR_SCALARS) {
13821                 switch (level) {
13822                         case 1: {
13823                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13824                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13825                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13826                         break; }
13827
13828                         default: {
13829                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13830                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13831                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13832                         break; }
13833
13834                 }
13835         }
13836         if (ndr_flags & NDR_BUFFERS) {
13837                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13838                 switch (level) {
13839                         case 1:
13840                         break;
13841
13842                         default:
13843                         break;
13844
13845                 }
13846         }
13847         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13848         return NDR_ERR_SUCCESS;
13849 }
13850
13851 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13852 {
13853         int level;
13854         level = ndr_print_get_switch_value(ndr, r);
13855         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13856         switch (level) {
13857                 case 1:
13858                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13859                 break;
13860
13861                 default:
13862                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13863                 break;
13864
13865         }
13866 }
13867
13868 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13869 {
13870         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13871 }
13872
13873 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13874 {
13875         if (ndr_flags & NDR_SCALARS) {
13876                 NDR_CHECK(ndr_push_align(ndr, 4));
13877                 {
13878                         uint32_t _flags_save_string = ndr->flags;
13879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13880                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13881                         ndr->flags = _flags_save_string;
13882                 }
13883         }
13884         if (ndr_flags & NDR_BUFFERS) {
13885                 {
13886                         uint32_t _flags_save_string = ndr->flags;
13887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13888                         if (r->print_processor_name) {
13889                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13890                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13891                         }
13892                         ndr->flags = _flags_save_string;
13893                 }
13894         }
13895         return NDR_ERR_SUCCESS;
13896 }
13897
13898 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13899 {
13900         uint32_t _ptr_print_processor_name;
13901         TALLOC_CTX *_mem_save_print_processor_name_0;
13902         if (ndr_flags & NDR_SCALARS) {
13903                 NDR_CHECK(ndr_pull_align(ndr, 4));
13904                 {
13905                         uint32_t _flags_save_string = ndr->flags;
13906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13908                         if (_ptr_print_processor_name) {
13909                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13911                         } else {
13912                                 r->print_processor_name = NULL;
13913                         }
13914                         ndr->flags = _flags_save_string;
13915                 }
13916         }
13917         if (ndr_flags & NDR_BUFFERS) {
13918                 {
13919                         uint32_t _flags_save_string = ndr->flags;
13920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13921                         if (r->print_processor_name) {
13922                                 uint32_t _relative_save_offset;
13923                                 _relative_save_offset = ndr->offset;
13924                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13925                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13926                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13927                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13928                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13929                                 ndr->offset = _relative_save_offset;
13930                         }
13931                         ndr->flags = _flags_save_string;
13932                 }
13933         }
13934         return NDR_ERR_SUCCESS;
13935 }
13936
13937 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13938 {
13939         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13940         ndr->depth++;
13941         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13942         ndr->depth++;
13943         if (r->print_processor_name) {
13944                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13945         }
13946         ndr->depth--;
13947         ndr->depth--;
13948 }
13949
13950 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13951 {
13952         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13953 }
13954
13955 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13956 {
13957         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13958         if (ndr_flags & NDR_SCALARS) {
13959                 int level = ndr_push_get_switch_value(ndr, r);
13960                 switch (level) {
13961                         case 1: {
13962                                 NDR_CHECK(ndr_push_align(ndr, 4));
13963                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13964                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13965                         break; }
13966
13967                         default: {
13968                         break; }
13969
13970                 }
13971         }
13972         if (ndr_flags & NDR_BUFFERS) {
13973                 int level = ndr_push_get_switch_value(ndr, r);
13974                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13975                 switch (level) {
13976                         case 1:
13977                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13978                         break;
13979
13980                         default:
13981                         break;
13982
13983                 }
13984         }
13985         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13986         return NDR_ERR_SUCCESS;
13987 }
13988
13989 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13990 {
13991         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13992         int level;
13993         level = ndr_pull_get_switch_value(ndr, r);
13994         if (ndr_flags & NDR_SCALARS) {
13995                 switch (level) {
13996                         case 1: {
13997                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13998                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13999                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14000                         break; }
14001
14002                         default: {
14003                         break; }
14004
14005                 }
14006         }
14007         if (ndr_flags & NDR_BUFFERS) {
14008                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14009                 switch (level) {
14010                         case 1:
14011                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14012                         break;
14013
14014                         default:
14015                         break;
14016
14017                 }
14018         }
14019         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14020         return NDR_ERR_SUCCESS;
14021 }
14022
14023 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14024 {
14025         int level;
14026         level = ndr_print_get_switch_value(ndr, r);
14027         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14028         switch (level) {
14029                 case 1:
14030                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14031                 break;
14032
14033                 default:
14034                 break;
14035
14036         }
14037 }
14038
14039 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14040 {
14041         if (ndr_flags & NDR_SCALARS) {
14042                 NDR_CHECK(ndr_push_align(ndr, 4));
14043                 {
14044                         uint32_t _flags_save_string = ndr->flags;
14045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14046                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14047                         ndr->flags = _flags_save_string;
14048                 }
14049         }
14050         if (ndr_flags & NDR_BUFFERS) {
14051         }
14052         return NDR_ERR_SUCCESS;
14053 }
14054
14055 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14056 {
14057         if (ndr_flags & NDR_SCALARS) {
14058                 NDR_CHECK(ndr_pull_align(ndr, 4));
14059                 {
14060                         uint32_t _flags_save_string = ndr->flags;
14061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14062                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14063                         ndr->flags = _flags_save_string;
14064                 }
14065         }
14066         if (ndr_flags & NDR_BUFFERS) {
14067         }
14068         return NDR_ERR_SUCCESS;
14069 }
14070
14071 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14072 {
14073         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14074         ndr->depth++;
14075         ndr_print_string(ndr, "directory_name", r->directory_name);
14076         ndr->depth--;
14077 }
14078
14079 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14080 {
14081         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14082 }
14083
14084 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14085 {
14086         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14087         if (ndr_flags & NDR_SCALARS) {
14088                 int level = ndr_push_get_switch_value(ndr, r);
14089                 switch (level) {
14090                         case 1: {
14091                                 NDR_CHECK(ndr_push_align(ndr, 4));
14092                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14093                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14094                         break; }
14095
14096                         default: {
14097                                 NDR_CHECK(ndr_push_align(ndr, 4));
14098                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14099                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14100                         break; }
14101
14102                 }
14103         }
14104         if (ndr_flags & NDR_BUFFERS) {
14105                 int level = ndr_push_get_switch_value(ndr, r);
14106                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14107                 switch (level) {
14108                         case 1:
14109                         break;
14110
14111                         default:
14112                         break;
14113
14114                 }
14115         }
14116         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14117         return NDR_ERR_SUCCESS;
14118 }
14119
14120 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14121 {
14122         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14123         int level;
14124         level = ndr_pull_get_switch_value(ndr, r);
14125         if (ndr_flags & NDR_SCALARS) {
14126                 switch (level) {
14127                         case 1: {
14128                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14129                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14130                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14131                         break; }
14132
14133                         default: {
14134                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14135                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14136                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14137                         break; }
14138
14139                 }
14140         }
14141         if (ndr_flags & NDR_BUFFERS) {
14142                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14143                 switch (level) {
14144                         case 1:
14145                         break;
14146
14147                         default:
14148                         break;
14149
14150                 }
14151         }
14152         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14153         return NDR_ERR_SUCCESS;
14154 }
14155
14156 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14157 {
14158         int level;
14159         level = ndr_print_get_switch_value(ndr, r);
14160         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14161         switch (level) {
14162                 case 1:
14163                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14164                 break;
14165
14166                 default:
14167                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14168                 break;
14169
14170         }
14171 }
14172
14173 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14174 {
14175         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14176 }
14177
14178 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14179 {
14180         if (ndr_flags & NDR_SCALARS) {
14181                 NDR_CHECK(ndr_push_align(ndr, 4));
14182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14185         }
14186         if (ndr_flags & NDR_BUFFERS) {
14187                 if (r->document_name) {
14188                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14189                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14190                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14191                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14192                 }
14193                 if (r->output_file) {
14194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14196                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14198                 }
14199                 if (r->datatype) {
14200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14202                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14203                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14204                 }
14205         }
14206         return NDR_ERR_SUCCESS;
14207 }
14208
14209 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14210 {
14211         uint32_t _ptr_document_name;
14212         TALLOC_CTX *_mem_save_document_name_0;
14213         uint32_t _ptr_output_file;
14214         TALLOC_CTX *_mem_save_output_file_0;
14215         uint32_t _ptr_datatype;
14216         TALLOC_CTX *_mem_save_datatype_0;
14217         if (ndr_flags & NDR_SCALARS) {
14218                 NDR_CHECK(ndr_pull_align(ndr, 4));
14219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14220                 if (_ptr_document_name) {
14221                         NDR_PULL_ALLOC(ndr, r->document_name);
14222                 } else {
14223                         r->document_name = NULL;
14224                 }
14225                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14226                 if (_ptr_output_file) {
14227                         NDR_PULL_ALLOC(ndr, r->output_file);
14228                 } else {
14229                         r->output_file = NULL;
14230                 }
14231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14232                 if (_ptr_datatype) {
14233                         NDR_PULL_ALLOC(ndr, r->datatype);
14234                 } else {
14235                         r->datatype = NULL;
14236                 }
14237         }
14238         if (ndr_flags & NDR_BUFFERS) {
14239                 if (r->document_name) {
14240                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14241                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14242                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14243                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14244                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14245                                 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));
14246                         }
14247                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14248                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14250                 }
14251                 if (r->output_file) {
14252                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14253                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14254                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14255                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14256                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14257                                 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));
14258                         }
14259                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14260                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14262                 }
14263                 if (r->datatype) {
14264                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14265                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14266                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14267                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14268                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14269                                 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));
14270                         }
14271                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14272                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14274                 }
14275         }
14276         return NDR_ERR_SUCCESS;
14277 }
14278
14279 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14280 {
14281         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14282         ndr->depth++;
14283         ndr_print_ptr(ndr, "document_name", r->document_name);
14284         ndr->depth++;
14285         if (r->document_name) {
14286                 ndr_print_string(ndr, "document_name", r->document_name);
14287         }
14288         ndr->depth--;
14289         ndr_print_ptr(ndr, "output_file", r->output_file);
14290         ndr->depth++;
14291         if (r->output_file) {
14292                 ndr_print_string(ndr, "output_file", r->output_file);
14293         }
14294         ndr->depth--;
14295         ndr_print_ptr(ndr, "datatype", r->datatype);
14296         ndr->depth++;
14297         if (r->datatype) {
14298                 ndr_print_string(ndr, "datatype", r->datatype);
14299         }
14300         ndr->depth--;
14301         ndr->depth--;
14302 }
14303
14304 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14305 {
14306         if (ndr_flags & NDR_SCALARS) {
14307                 int level = ndr_push_get_switch_value(ndr, r);
14308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14309                 switch (level) {
14310                         case 1: {
14311                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14312                         break; }
14313
14314                         case 2: {
14315                         break; }
14316
14317                         case 3: {
14318                         break; }
14319
14320                         default: {
14321                         break; }
14322
14323                 }
14324         }
14325         if (ndr_flags & NDR_BUFFERS) {
14326                 int level = ndr_push_get_switch_value(ndr, r);
14327                 switch (level) {
14328                         case 1:
14329                                 if (r->info1) {
14330                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14331                                 }
14332                         break;
14333
14334                         case 2:
14335                         break;
14336
14337                         case 3:
14338                         break;
14339
14340                         default:
14341                         break;
14342
14343                 }
14344         }
14345         return NDR_ERR_SUCCESS;
14346 }
14347
14348 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14349 {
14350         int level;
14351         uint32_t _level;
14352         TALLOC_CTX *_mem_save_info1_0;
14353         level = ndr_pull_get_switch_value(ndr, r);
14354         if (ndr_flags & NDR_SCALARS) {
14355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14356                 if (_level != level) {
14357                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14358                 }
14359                 switch (level) {
14360                         case 1: {
14361                                 uint32_t _ptr_info1;
14362                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14363                                 if (_ptr_info1) {
14364                                         NDR_PULL_ALLOC(ndr, r->info1);
14365                                 } else {
14366                                         r->info1 = NULL;
14367                                 }
14368                         break; }
14369
14370                         case 2: {
14371                         break; }
14372
14373                         case 3: {
14374                         break; }
14375
14376                         default: {
14377                         break; }
14378
14379                 }
14380         }
14381         if (ndr_flags & NDR_BUFFERS) {
14382                 switch (level) {
14383                         case 1:
14384                                 if (r->info1) {
14385                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14386                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14387                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14388                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14389                                 }
14390                         break;
14391
14392                         case 2:
14393                         break;
14394
14395                         case 3:
14396                         break;
14397
14398                         default:
14399                         break;
14400
14401                 }
14402         }
14403         return NDR_ERR_SUCCESS;
14404 }
14405
14406 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14407 {
14408         int level;
14409         level = ndr_print_get_switch_value(ndr, r);
14410         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14411         switch (level) {
14412                 case 1:
14413                         ndr_print_ptr(ndr, "info1", r->info1);
14414                         ndr->depth++;
14415                         if (r->info1) {
14416                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14417                         }
14418                         ndr->depth--;
14419                 break;
14420
14421                 case 2:
14422                 break;
14423
14424                 case 3:
14425                 break;
14426
14427                 default:
14428                 break;
14429
14430         }
14431 }
14432
14433 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14434 {
14435         if (ndr_flags & NDR_SCALARS) {
14436                 NDR_CHECK(ndr_push_align(ndr, 4));
14437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14442                 {
14443                         uint32_t _flags_save_string = ndr->flags;
14444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14445                         {
14446                                 struct ndr_push *_ndr_extra_string;
14447                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14448                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14449                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14450                         }
14451                         ndr->flags = _flags_save_string;
14452                 }
14453         }
14454         if (ndr_flags & NDR_BUFFERS) {
14455         }
14456         return NDR_ERR_SUCCESS;
14457 }
14458
14459 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14460 {
14461         if (ndr_flags & NDR_SCALARS) {
14462                 NDR_CHECK(ndr_pull_align(ndr, 4));
14463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14468                 {
14469                         uint32_t _flags_save_string = ndr->flags;
14470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14471                         {
14472                                 struct ndr_pull *_ndr_extra_string;
14473                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14474                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14475                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14476                         }
14477                         ndr->flags = _flags_save_string;
14478                 }
14479         }
14480         if (ndr_flags & NDR_BUFFERS) {
14481         }
14482         return NDR_ERR_SUCCESS;
14483 }
14484
14485 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14486 {
14487         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14488         ndr->depth++;
14489         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);
14490         ndr_print_uint32(ndr, "major", r->major);
14491         ndr_print_uint32(ndr, "minor", r->minor);
14492         ndr_print_uint32(ndr, "build", r->build);
14493         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14494         ndr_print_string(ndr, "extra_string", r->extra_string);
14495         ndr->depth--;
14496 }
14497
14498 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14499 {
14500         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14501 }
14502
14503 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14504 {
14505         if (ndr_flags & NDR_SCALARS) {
14506                 NDR_CHECK(ndr_push_align(ndr, 4));
14507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14512                 {
14513                         uint32_t _flags_save_string = ndr->flags;
14514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14515                         {
14516                                 struct ndr_push *_ndr_extra_string;
14517                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14518                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14519                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14520                         }
14521                         ndr->flags = _flags_save_string;
14522                 }
14523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14525         }
14526         if (ndr_flags & NDR_BUFFERS) {
14527         }
14528         return NDR_ERR_SUCCESS;
14529 }
14530
14531 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14532 {
14533         if (ndr_flags & NDR_SCALARS) {
14534                 NDR_CHECK(ndr_pull_align(ndr, 4));
14535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14540                 {
14541                         uint32_t _flags_save_string = ndr->flags;
14542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14543                         {
14544                                 struct ndr_pull *_ndr_extra_string;
14545                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14546                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14547                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14548                         }
14549                         ndr->flags = _flags_save_string;
14550                 }
14551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14553         }
14554         if (ndr_flags & NDR_BUFFERS) {
14555         }
14556         return NDR_ERR_SUCCESS;
14557 }
14558
14559 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14560 {
14561         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14562         ndr->depth++;
14563         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);
14564         ndr_print_uint32(ndr, "major", r->major);
14565         ndr_print_uint32(ndr, "minor", r->minor);
14566         ndr_print_uint32(ndr, "build", r->build);
14567         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14568         ndr_print_string(ndr, "extra_string", r->extra_string);
14569         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14570         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14571         ndr->depth--;
14572 }
14573
14574 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14575 {
14576         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14577 }
14578
14579 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14580 {
14581         if (ndr_flags & NDR_SCALARS) {
14582                 int level = ndr_push_get_switch_value(ndr, r);
14583                 switch (level) {
14584                         case REG_NONE: {
14585                         break; }
14586
14587                         case REG_SZ: {
14588                                 {
14589                                         uint32_t _flags_save_string = ndr->flags;
14590                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14591                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14592                                         ndr->flags = _flags_save_string;
14593                                 }
14594                         break; }
14595
14596                         case REG_BINARY: {
14597                                 {
14598                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14599                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14600                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14601                                         ndr->flags = _flags_save_DATA_BLOB;
14602                                 }
14603                         break; }
14604
14605                         case REG_DWORD: {
14606                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14607                         break; }
14608
14609                         case REG_MULTI_SZ: {
14610                                 {
14611                                         uint32_t _flags_save_string_array = ndr->flags;
14612                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14613                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14614                                         ndr->flags = _flags_save_string_array;
14615                                 }
14616                         break; }
14617
14618                         default: {
14619                                 {
14620                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14621                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14622                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14623                                         ndr->flags = _flags_save_DATA_BLOB;
14624                                 }
14625                         break; }
14626
14627                 }
14628         }
14629         if (ndr_flags & NDR_BUFFERS) {
14630                 int level = ndr_push_get_switch_value(ndr, r);
14631                 switch (level) {
14632                         case REG_NONE:
14633                         break;
14634
14635                         case REG_SZ:
14636                         break;
14637
14638                         case REG_BINARY:
14639                         break;
14640
14641                         case REG_DWORD:
14642                         break;
14643
14644                         case REG_MULTI_SZ:
14645                         break;
14646
14647                         default:
14648                         break;
14649
14650                 }
14651         }
14652         return NDR_ERR_SUCCESS;
14653 }
14654
14655 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14656 {
14657         int level;
14658         level = ndr_pull_get_switch_value(ndr, r);
14659         if (ndr_flags & NDR_SCALARS) {
14660                 switch (level) {
14661                         case REG_NONE: {
14662                         break; }
14663
14664                         case REG_SZ: {
14665                                 {
14666                                         uint32_t _flags_save_string = ndr->flags;
14667                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14668                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14669                                         ndr->flags = _flags_save_string;
14670                                 }
14671                         break; }
14672
14673                         case REG_BINARY: {
14674                                 {
14675                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14676                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14677                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14678                                         ndr->flags = _flags_save_DATA_BLOB;
14679                                 }
14680                         break; }
14681
14682                         case REG_DWORD: {
14683                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14684                         break; }
14685
14686                         case REG_MULTI_SZ: {
14687                                 {
14688                                         uint32_t _flags_save_string_array = ndr->flags;
14689                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14690                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14691                                         ndr->flags = _flags_save_string_array;
14692                                 }
14693                         break; }
14694
14695                         default: {
14696                                 {
14697                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14698                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14699                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14700                                         ndr->flags = _flags_save_DATA_BLOB;
14701                                 }
14702                         break; }
14703
14704                 }
14705         }
14706         if (ndr_flags & NDR_BUFFERS) {
14707                 switch (level) {
14708                         case REG_NONE:
14709                         break;
14710
14711                         case REG_SZ:
14712                         break;
14713
14714                         case REG_BINARY:
14715                         break;
14716
14717                         case REG_DWORD:
14718                         break;
14719
14720                         case REG_MULTI_SZ:
14721                         break;
14722
14723                         default:
14724                         break;
14725
14726                 }
14727         }
14728         return NDR_ERR_SUCCESS;
14729 }
14730
14731 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14732 {
14733         int level;
14734         level = ndr_print_get_switch_value(ndr, r);
14735         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14736         switch (level) {
14737                 case REG_NONE:
14738                 break;
14739
14740                 case REG_SZ:
14741                         ndr_print_string(ndr, "string", r->string);
14742                 break;
14743
14744                 case REG_BINARY:
14745                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14746                 break;
14747
14748                 case REG_DWORD:
14749                         ndr_print_uint32(ndr, "value", r->value);
14750                 break;
14751
14752                 case REG_MULTI_SZ:
14753                         ndr_print_string_array(ndr, "string_array", r->string_array);
14754                 break;
14755
14756                 default:
14757                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14758                 break;
14759
14760         }
14761 }
14762
14763 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14764 {
14765         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14766 }
14767
14768 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14769 {
14770         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14771         return NDR_ERR_SUCCESS;
14772 }
14773
14774 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14775 {
14776         uint32_t v;
14777         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14778         *r = v;
14779         return NDR_ERR_SUCCESS;
14780 }
14781
14782 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14783 {
14784         const char *val = NULL;
14785
14786         switch (r) {
14787                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14788                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14789                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14790         }
14791         ndr_print_enum(ndr, name, "ENUM", val, r);
14792 }
14793
14794 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14795 {
14796         if (ndr_flags & NDR_SCALARS) {
14797                 NDR_CHECK(ndr_push_align(ndr, 4));
14798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14800         }
14801         if (ndr_flags & NDR_BUFFERS) {
14802         }
14803         return NDR_ERR_SUCCESS;
14804 }
14805
14806 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14807 {
14808         if (ndr_flags & NDR_SCALARS) {
14809                 NDR_CHECK(ndr_pull_align(ndr, 4));
14810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14812         }
14813         if (ndr_flags & NDR_BUFFERS) {
14814         }
14815         return NDR_ERR_SUCCESS;
14816 }
14817
14818 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14819 {
14820         ndr_print_struct(ndr, name, "spoolss_FormSize");
14821         ndr->depth++;
14822         ndr_print_uint32(ndr, "width", r->width);
14823         ndr_print_uint32(ndr, "height", r->height);
14824         ndr->depth--;
14825 }
14826
14827 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14828 {
14829         if (ndr_flags & NDR_SCALARS) {
14830                 NDR_CHECK(ndr_push_align(ndr, 4));
14831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14835         }
14836         if (ndr_flags & NDR_BUFFERS) {
14837         }
14838         return NDR_ERR_SUCCESS;
14839 }
14840
14841 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14842 {
14843         if (ndr_flags & NDR_SCALARS) {
14844                 NDR_CHECK(ndr_pull_align(ndr, 4));
14845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14849         }
14850         if (ndr_flags & NDR_BUFFERS) {
14851         }
14852         return NDR_ERR_SUCCESS;
14853 }
14854
14855 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14856 {
14857         ndr_print_struct(ndr, name, "spoolss_FormArea");
14858         ndr->depth++;
14859         ndr_print_uint32(ndr, "left", r->left);
14860         ndr_print_uint32(ndr, "top", r->top);
14861         ndr_print_uint32(ndr, "right", r->right);
14862         ndr_print_uint32(ndr, "bottom", r->bottom);
14863         ndr->depth--;
14864 }
14865
14866 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14867 {
14868         if (ndr_flags & NDR_SCALARS) {
14869                 NDR_CHECK(ndr_push_align(ndr, 4));
14870                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14871                 {
14872                         uint32_t _flags_save_string = ndr->flags;
14873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14874                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14875                         ndr->flags = _flags_save_string;
14876                 }
14877                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14878                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14879         }
14880         if (ndr_flags & NDR_BUFFERS) {
14881                 {
14882                         uint32_t _flags_save_string = ndr->flags;
14883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14884                         if (r->form_name) {
14885                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14886                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14887                         }
14888                         ndr->flags = _flags_save_string;
14889                 }
14890         }
14891         return NDR_ERR_SUCCESS;
14892 }
14893
14894 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14895 {
14896         uint32_t _ptr_form_name;
14897         TALLOC_CTX *_mem_save_form_name_0;
14898         if (ndr_flags & NDR_SCALARS) {
14899                 NDR_CHECK(ndr_pull_align(ndr, 4));
14900                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14901                 {
14902                         uint32_t _flags_save_string = ndr->flags;
14903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14905                         if (_ptr_form_name) {
14906                                 NDR_PULL_ALLOC(ndr, r->form_name);
14907                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14908                         } else {
14909                                 r->form_name = NULL;
14910                         }
14911                         ndr->flags = _flags_save_string;
14912                 }
14913                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14914                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14915         }
14916         if (ndr_flags & NDR_BUFFERS) {
14917                 {
14918                         uint32_t _flags_save_string = ndr->flags;
14919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14920                         if (r->form_name) {
14921                                 uint32_t _relative_save_offset;
14922                                 _relative_save_offset = ndr->offset;
14923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14924                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14925                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14928                                 ndr->offset = _relative_save_offset;
14929                         }
14930                         ndr->flags = _flags_save_string;
14931                 }
14932         }
14933         return NDR_ERR_SUCCESS;
14934 }
14935
14936 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14937 {
14938         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14939         ndr->depth++;
14940         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14941         ndr_print_ptr(ndr, "form_name", r->form_name);
14942         ndr->depth++;
14943         if (r->form_name) {
14944                 ndr_print_string(ndr, "form_name", r->form_name);
14945         }
14946         ndr->depth--;
14947         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14948         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14949         ndr->depth--;
14950 }
14951
14952 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14953 {
14954         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14955 }
14956
14957 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14958 {
14959         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14960         return NDR_ERR_SUCCESS;
14961 }
14962
14963 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14964 {
14965         uint32_t v;
14966         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14967         *r = v;
14968         return NDR_ERR_SUCCESS;
14969 }
14970
14971 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14972 {
14973         ndr_print_uint32(ndr, name, r);
14974         ndr->depth++;
14975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14978         ndr->depth--;
14979 }
14980
14981 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14982 {
14983         if (ndr_flags & NDR_SCALARS) {
14984                 NDR_CHECK(ndr_push_align(ndr, 4));
14985                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14986                 {
14987                         uint32_t _flags_save_string = ndr->flags;
14988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14989                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14990                         ndr->flags = _flags_save_string;
14991                 }
14992                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14993                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14994                 {
14995                         uint32_t _flags_save_string = ndr->flags;
14996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14997                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14998                         ndr->flags = _flags_save_string;
14999                 }
15000                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15001                 {
15002                         uint32_t _flags_save_string = ndr->flags;
15003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15004                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15005                         ndr->flags = _flags_save_string;
15006                 }
15007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15008                 {
15009                         uint32_t _flags_save_string = ndr->flags;
15010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15012                         ndr->flags = _flags_save_string;
15013                 }
15014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15015         }
15016         if (ndr_flags & NDR_BUFFERS) {
15017                 {
15018                         uint32_t _flags_save_string = ndr->flags;
15019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15020                         if (r->form_name) {
15021                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15022                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15023                         }
15024                         ndr->flags = _flags_save_string;
15025                 }
15026                 {
15027                         uint32_t _flags_save_string = ndr->flags;
15028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15029                         if (r->keyword) {
15030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15032                         }
15033                         ndr->flags = _flags_save_string;
15034                 }
15035                 {
15036                         uint32_t _flags_save_string = ndr->flags;
15037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15038                         if (r->mui_dll) {
15039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15041                         }
15042                         ndr->flags = _flags_save_string;
15043                 }
15044                 {
15045                         uint32_t _flags_save_string = ndr->flags;
15046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15047                         if (r->display_name) {
15048                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15049                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15050                         }
15051                         ndr->flags = _flags_save_string;
15052                 }
15053         }
15054         return NDR_ERR_SUCCESS;
15055 }
15056
15057 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15058 {
15059         uint32_t _ptr_form_name;
15060         TALLOC_CTX *_mem_save_form_name_0;
15061         uint32_t _ptr_keyword;
15062         TALLOC_CTX *_mem_save_keyword_0;
15063         uint32_t _ptr_mui_dll;
15064         TALLOC_CTX *_mem_save_mui_dll_0;
15065         uint32_t _ptr_display_name;
15066         TALLOC_CTX *_mem_save_display_name_0;
15067         if (ndr_flags & NDR_SCALARS) {
15068                 NDR_CHECK(ndr_pull_align(ndr, 4));
15069                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15070                 {
15071                         uint32_t _flags_save_string = ndr->flags;
15072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15073                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15074                         if (_ptr_form_name) {
15075                                 NDR_PULL_ALLOC(ndr, r->form_name);
15076                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15077                         } else {
15078                                 r->form_name = NULL;
15079                         }
15080                         ndr->flags = _flags_save_string;
15081                 }
15082                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15083                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15084                 {
15085                         uint32_t _flags_save_string = ndr->flags;
15086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15087                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15088                         if (_ptr_keyword) {
15089                                 NDR_PULL_ALLOC(ndr, r->keyword);
15090                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15091                         } else {
15092                                 r->keyword = NULL;
15093                         }
15094                         ndr->flags = _flags_save_string;
15095                 }
15096                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15097                 {
15098                         uint32_t _flags_save_string = ndr->flags;
15099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15100                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15101                         if (_ptr_mui_dll) {
15102                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15103                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15104                         } else {
15105                                 r->mui_dll = NULL;
15106                         }
15107                         ndr->flags = _flags_save_string;
15108                 }
15109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15110                 {
15111                         uint32_t _flags_save_string = ndr->flags;
15112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15113                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15114                         if (_ptr_display_name) {
15115                                 NDR_PULL_ALLOC(ndr, r->display_name);
15116                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15117                         } else {
15118                                 r->display_name = NULL;
15119                         }
15120                         ndr->flags = _flags_save_string;
15121                 }
15122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15123         }
15124         if (ndr_flags & NDR_BUFFERS) {
15125                 {
15126                         uint32_t _flags_save_string = ndr->flags;
15127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15128                         if (r->form_name) {
15129                                 uint32_t _relative_save_offset;
15130                                 _relative_save_offset = ndr->offset;
15131                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15132                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15133                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15134                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15135                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15136                                 ndr->offset = _relative_save_offset;
15137                         }
15138                         ndr->flags = _flags_save_string;
15139                 }
15140                 {
15141                         uint32_t _flags_save_string = ndr->flags;
15142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15143                         if (r->keyword) {
15144                                 uint32_t _relative_save_offset;
15145                                 _relative_save_offset = ndr->offset;
15146                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15147                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15148                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15149                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15150                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15151                                 ndr->offset = _relative_save_offset;
15152                         }
15153                         ndr->flags = _flags_save_string;
15154                 }
15155                 {
15156                         uint32_t _flags_save_string = ndr->flags;
15157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15158                         if (r->mui_dll) {
15159                                 uint32_t _relative_save_offset;
15160                                 _relative_save_offset = ndr->offset;
15161                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15162                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15163                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15164                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15165                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15166                                 ndr->offset = _relative_save_offset;
15167                         }
15168                         ndr->flags = _flags_save_string;
15169                 }
15170                 {
15171                         uint32_t _flags_save_string = ndr->flags;
15172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15173                         if (r->display_name) {
15174                                 uint32_t _relative_save_offset;
15175                                 _relative_save_offset = ndr->offset;
15176                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15177                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15178                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15179                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15180                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15181                                 ndr->offset = _relative_save_offset;
15182                         }
15183                         ndr->flags = _flags_save_string;
15184                 }
15185         }
15186         return NDR_ERR_SUCCESS;
15187 }
15188
15189 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15190 {
15191         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15192         ndr->depth++;
15193         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15194         ndr_print_ptr(ndr, "form_name", r->form_name);
15195         ndr->depth++;
15196         if (r->form_name) {
15197                 ndr_print_string(ndr, "form_name", r->form_name);
15198         }
15199         ndr->depth--;
15200         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15201         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15202         ndr_print_ptr(ndr, "keyword", r->keyword);
15203         ndr->depth++;
15204         if (r->keyword) {
15205                 ndr_print_string(ndr, "keyword", r->keyword);
15206         }
15207         ndr->depth--;
15208         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15209         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15210         ndr->depth++;
15211         if (r->mui_dll) {
15212                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15213         }
15214         ndr->depth--;
15215         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15216         ndr_print_ptr(ndr, "display_name", r->display_name);
15217         ndr->depth++;
15218         if (r->display_name) {
15219                 ndr_print_string(ndr, "display_name", r->display_name);
15220         }
15221         ndr->depth--;
15222         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15223         ndr->depth--;
15224 }
15225
15226 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15227 {
15228         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15229 }
15230
15231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15232 {
15233         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15234         if (ndr_flags & NDR_SCALARS) {
15235                 int level = ndr_push_get_switch_value(ndr, r);
15236                 switch (level) {
15237                         case 1: {
15238                                 NDR_CHECK(ndr_push_align(ndr, 4));
15239                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15240                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15241                         break; }
15242
15243                         case 2: {
15244                                 NDR_CHECK(ndr_push_align(ndr, 4));
15245                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15246                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15247                         break; }
15248
15249                         default: {
15250                         break; }
15251
15252                 }
15253         }
15254         if (ndr_flags & NDR_BUFFERS) {
15255                 int level = ndr_push_get_switch_value(ndr, r);
15256                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15257                 switch (level) {
15258                         case 1:
15259                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15260                         break;
15261
15262                         case 2:
15263                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15264                         break;
15265
15266                         default:
15267                         break;
15268
15269                 }
15270         }
15271         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15272         return NDR_ERR_SUCCESS;
15273 }
15274
15275 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15276 {
15277         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15278         int level;
15279         level = ndr_pull_get_switch_value(ndr, r);
15280         if (ndr_flags & NDR_SCALARS) {
15281                 switch (level) {
15282                         case 1: {
15283                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15284                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15285                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15286                         break; }
15287
15288                         case 2: {
15289                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15290                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15291                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15292                         break; }
15293
15294                         default: {
15295                         break; }
15296
15297                 }
15298         }
15299         if (ndr_flags & NDR_BUFFERS) {
15300                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15301                 switch (level) {
15302                         case 1:
15303                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15304                         break;
15305
15306                         case 2:
15307                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15308                         break;
15309
15310                         default:
15311                         break;
15312
15313                 }
15314         }
15315         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15316         return NDR_ERR_SUCCESS;
15317 }
15318
15319 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15320 {
15321         int level;
15322         level = ndr_print_get_switch_value(ndr, r);
15323         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15324         switch (level) {
15325                 case 1:
15326                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15327                 break;
15328
15329                 case 2:
15330                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15331                 break;
15332
15333                 default:
15334                 break;
15335
15336         }
15337 }
15338
15339 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15340 {
15341         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15342 }
15343
15344 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15345 {
15346         if (ndr_flags & NDR_SCALARS) {
15347                 NDR_CHECK(ndr_push_align(ndr, 4));
15348                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15350                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15351                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15352         }
15353         if (ndr_flags & NDR_BUFFERS) {
15354                 if (r->form_name) {
15355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15358                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15359                 }
15360         }
15361         return NDR_ERR_SUCCESS;
15362 }
15363
15364 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15365 {
15366         uint32_t _ptr_form_name;
15367         TALLOC_CTX *_mem_save_form_name_0;
15368         if (ndr_flags & NDR_SCALARS) {
15369                 NDR_CHECK(ndr_pull_align(ndr, 4));
15370                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15372                 if (_ptr_form_name) {
15373                         NDR_PULL_ALLOC(ndr, r->form_name);
15374                 } else {
15375                         r->form_name = NULL;
15376                 }
15377                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15378                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15379         }
15380         if (ndr_flags & NDR_BUFFERS) {
15381                 if (r->form_name) {
15382                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15383                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15386                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15387                                 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));
15388                         }
15389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15392                 }
15393         }
15394         return NDR_ERR_SUCCESS;
15395 }
15396
15397 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15398 {
15399         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15400         ndr->depth++;
15401         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15402         ndr_print_ptr(ndr, "form_name", r->form_name);
15403         ndr->depth++;
15404         if (r->form_name) {
15405                 ndr_print_string(ndr, "form_name", r->form_name);
15406         }
15407         ndr->depth--;
15408         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15409         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15410         ndr->depth--;
15411 }
15412
15413 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15414 {
15415         if (ndr_flags & NDR_SCALARS) {
15416                 NDR_CHECK(ndr_push_align(ndr, 4));
15417                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15419                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15420                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15422                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15427         }
15428         if (ndr_flags & NDR_BUFFERS) {
15429                 if (r->form_name) {
15430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15434                 }
15435                 if (r->keyword) {
15436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15440                 }
15441                 if (r->mui_dll) {
15442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15446                 }
15447                 if (r->display_name) {
15448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15452                 }
15453         }
15454         return NDR_ERR_SUCCESS;
15455 }
15456
15457 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15458 {
15459         uint32_t _ptr_form_name;
15460         TALLOC_CTX *_mem_save_form_name_0;
15461         uint32_t _ptr_keyword;
15462         TALLOC_CTX *_mem_save_keyword_0;
15463         uint32_t _ptr_mui_dll;
15464         TALLOC_CTX *_mem_save_mui_dll_0;
15465         uint32_t _ptr_display_name;
15466         TALLOC_CTX *_mem_save_display_name_0;
15467         if (ndr_flags & NDR_SCALARS) {
15468                 NDR_CHECK(ndr_pull_align(ndr, 4));
15469                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15471                 if (_ptr_form_name) {
15472                         NDR_PULL_ALLOC(ndr, r->form_name);
15473                 } else {
15474                         r->form_name = NULL;
15475                 }
15476                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15477                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15479                 if (_ptr_keyword) {
15480                         NDR_PULL_ALLOC(ndr, r->keyword);
15481                 } else {
15482                         r->keyword = NULL;
15483                 }
15484                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15486                 if (_ptr_mui_dll) {
15487                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15488                 } else {
15489                         r->mui_dll = NULL;
15490                 }
15491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15493                 if (_ptr_display_name) {
15494                         NDR_PULL_ALLOC(ndr, r->display_name);
15495                 } else {
15496                         r->display_name = NULL;
15497                 }
15498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15499         }
15500         if (ndr_flags & NDR_BUFFERS) {
15501                 if (r->form_name) {
15502                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15503                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15504                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15505                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15506                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15507                                 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));
15508                         }
15509                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15510                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15512                 }
15513                 if (r->keyword) {
15514                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15515                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15516                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15517                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15518                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15519                                 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));
15520                         }
15521                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15522                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15524                 }
15525                 if (r->mui_dll) {
15526                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15527                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15530                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15531                                 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));
15532                         }
15533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15536                 }
15537                 if (r->display_name) {
15538                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15539                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15542                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15543                                 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));
15544                         }
15545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15548                 }
15549         }
15550         return NDR_ERR_SUCCESS;
15551 }
15552
15553 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15554 {
15555         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15556         ndr->depth++;
15557         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15558         ndr_print_ptr(ndr, "form_name", r->form_name);
15559         ndr->depth++;
15560         if (r->form_name) {
15561                 ndr_print_string(ndr, "form_name", r->form_name);
15562         }
15563         ndr->depth--;
15564         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15565         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15566         ndr_print_ptr(ndr, "keyword", r->keyword);
15567         ndr->depth++;
15568         if (r->keyword) {
15569                 ndr_print_string(ndr, "keyword", r->keyword);
15570         }
15571         ndr->depth--;
15572         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15573         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15574         ndr->depth++;
15575         if (r->mui_dll) {
15576                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15577         }
15578         ndr->depth--;
15579         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15580         ndr_print_ptr(ndr, "display_name", r->display_name);
15581         ndr->depth++;
15582         if (r->display_name) {
15583                 ndr_print_string(ndr, "display_name", r->display_name);
15584         }
15585         ndr->depth--;
15586         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15587         ndr->depth--;
15588 }
15589
15590 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15591 {
15592         if (ndr_flags & NDR_SCALARS) {
15593                 int level = ndr_push_get_switch_value(ndr, r);
15594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15595                 switch (level) {
15596                         case 1: {
15597                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15598                         break; }
15599
15600                         case 2: {
15601                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15602                         break; }
15603
15604                         default:
15605                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15606                 }
15607         }
15608         if (ndr_flags & NDR_BUFFERS) {
15609                 int level = ndr_push_get_switch_value(ndr, r);
15610                 switch (level) {
15611                         case 1:
15612                                 if (r->info1) {
15613                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15614                                 }
15615                         break;
15616
15617                         case 2:
15618                                 if (r->info2) {
15619                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15620                                 }
15621                         break;
15622
15623                         default:
15624                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15625                 }
15626         }
15627         return NDR_ERR_SUCCESS;
15628 }
15629
15630 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15631 {
15632         int level;
15633         uint32_t _level;
15634         TALLOC_CTX *_mem_save_info1_0;
15635         TALLOC_CTX *_mem_save_info2_0;
15636         level = ndr_pull_get_switch_value(ndr, r);
15637         if (ndr_flags & NDR_SCALARS) {
15638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15639                 if (_level != level) {
15640                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15641                 }
15642                 switch (level) {
15643                         case 1: {
15644                                 uint32_t _ptr_info1;
15645                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15646                                 if (_ptr_info1) {
15647                                         NDR_PULL_ALLOC(ndr, r->info1);
15648                                 } else {
15649                                         r->info1 = NULL;
15650                                 }
15651                         break; }
15652
15653                         case 2: {
15654                                 uint32_t _ptr_info2;
15655                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15656                                 if (_ptr_info2) {
15657                                         NDR_PULL_ALLOC(ndr, r->info2);
15658                                 } else {
15659                                         r->info2 = NULL;
15660                                 }
15661                         break; }
15662
15663                         default:
15664                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15665                 }
15666         }
15667         if (ndr_flags & NDR_BUFFERS) {
15668                 switch (level) {
15669                         case 1:
15670                                 if (r->info1) {
15671                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15672                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15673                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15674                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15675                                 }
15676                         break;
15677
15678                         case 2:
15679                                 if (r->info2) {
15680                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15681                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15682                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15683                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15684                                 }
15685                         break;
15686
15687                         default:
15688                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15689                 }
15690         }
15691         return NDR_ERR_SUCCESS;
15692 }
15693
15694 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15695 {
15696         int level;
15697         level = ndr_print_get_switch_value(ndr, r);
15698         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15699         switch (level) {
15700                 case 1:
15701                         ndr_print_ptr(ndr, "info1", r->info1);
15702                         ndr->depth++;
15703                         if (r->info1) {
15704                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15705                         }
15706                         ndr->depth--;
15707                 break;
15708
15709                 case 2:
15710                         ndr_print_ptr(ndr, "info2", r->info2);
15711                         ndr->depth++;
15712                         if (r->info2) {
15713                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15714                         }
15715                         ndr->depth--;
15716                 break;
15717
15718                 default:
15719                         ndr_print_bad_level(ndr, name, level);
15720         }
15721 }
15722
15723 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15724 {
15725         if (ndr_flags & NDR_SCALARS) {
15726                 NDR_CHECK(ndr_push_align(ndr, 4));
15727                 {
15728                         uint32_t _flags_save_string = ndr->flags;
15729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15730                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15731                         ndr->flags = _flags_save_string;
15732                 }
15733         }
15734         if (ndr_flags & NDR_BUFFERS) {
15735                 {
15736                         uint32_t _flags_save_string = ndr->flags;
15737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15738                         if (r->port_name) {
15739                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15740                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15741                         }
15742                         ndr->flags = _flags_save_string;
15743                 }
15744         }
15745         return NDR_ERR_SUCCESS;
15746 }
15747
15748 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15749 {
15750         uint32_t _ptr_port_name;
15751         TALLOC_CTX *_mem_save_port_name_0;
15752         if (ndr_flags & NDR_SCALARS) {
15753                 NDR_CHECK(ndr_pull_align(ndr, 4));
15754                 {
15755                         uint32_t _flags_save_string = ndr->flags;
15756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15757                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15758                         if (_ptr_port_name) {
15759                                 NDR_PULL_ALLOC(ndr, r->port_name);
15760                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15761                         } else {
15762                                 r->port_name = NULL;
15763                         }
15764                         ndr->flags = _flags_save_string;
15765                 }
15766         }
15767         if (ndr_flags & NDR_BUFFERS) {
15768                 {
15769                         uint32_t _flags_save_string = ndr->flags;
15770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15771                         if (r->port_name) {
15772                                 uint32_t _relative_save_offset;
15773                                 _relative_save_offset = ndr->offset;
15774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15775                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15776                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15779                                 ndr->offset = _relative_save_offset;
15780                         }
15781                         ndr->flags = _flags_save_string;
15782                 }
15783         }
15784         return NDR_ERR_SUCCESS;
15785 }
15786
15787 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15788 {
15789         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15790         ndr->depth++;
15791         ndr_print_ptr(ndr, "port_name", r->port_name);
15792         ndr->depth++;
15793         if (r->port_name) {
15794                 ndr_print_string(ndr, "port_name", r->port_name);
15795         }
15796         ndr->depth--;
15797         ndr->depth--;
15798 }
15799
15800 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15801 {
15802         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15803 }
15804
15805 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15806 {
15807         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15808         return NDR_ERR_SUCCESS;
15809 }
15810
15811 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15812 {
15813         uint32_t v;
15814         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15815         *r = v;
15816         return NDR_ERR_SUCCESS;
15817 }
15818
15819 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15820 {
15821         ndr_print_uint32(ndr, name, r);
15822         ndr->depth++;
15823         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15824         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15825         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15826         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15827         ndr->depth--;
15828 }
15829
15830 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15831 {
15832         if (ndr_flags & NDR_SCALARS) {
15833                 NDR_CHECK(ndr_push_align(ndr, 4));
15834                 {
15835                         uint32_t _flags_save_string = ndr->flags;
15836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15837                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15838                         ndr->flags = _flags_save_string;
15839                 }
15840                 {
15841                         uint32_t _flags_save_string = ndr->flags;
15842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15843                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15844                         ndr->flags = _flags_save_string;
15845                 }
15846                 {
15847                         uint32_t _flags_save_string = ndr->flags;
15848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15849                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15850                         ndr->flags = _flags_save_string;
15851                 }
15852                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15854         }
15855         if (ndr_flags & NDR_BUFFERS) {
15856                 {
15857                         uint32_t _flags_save_string = ndr->flags;
15858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15859                         if (r->port_name) {
15860                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15861                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15862                         }
15863                         ndr->flags = _flags_save_string;
15864                 }
15865                 {
15866                         uint32_t _flags_save_string = ndr->flags;
15867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15868                         if (r->monitor_name) {
15869                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15870                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15871                         }
15872                         ndr->flags = _flags_save_string;
15873                 }
15874                 {
15875                         uint32_t _flags_save_string = ndr->flags;
15876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15877                         if (r->description) {
15878                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15879                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15880                         }
15881                         ndr->flags = _flags_save_string;
15882                 }
15883         }
15884         return NDR_ERR_SUCCESS;
15885 }
15886
15887 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15888 {
15889         uint32_t _ptr_port_name;
15890         TALLOC_CTX *_mem_save_port_name_0;
15891         uint32_t _ptr_monitor_name;
15892         TALLOC_CTX *_mem_save_monitor_name_0;
15893         uint32_t _ptr_description;
15894         TALLOC_CTX *_mem_save_description_0;
15895         if (ndr_flags & NDR_SCALARS) {
15896                 NDR_CHECK(ndr_pull_align(ndr, 4));
15897                 {
15898                         uint32_t _flags_save_string = ndr->flags;
15899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15900                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15901                         if (_ptr_port_name) {
15902                                 NDR_PULL_ALLOC(ndr, r->port_name);
15903                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15904                         } else {
15905                                 r->port_name = NULL;
15906                         }
15907                         ndr->flags = _flags_save_string;
15908                 }
15909                 {
15910                         uint32_t _flags_save_string = ndr->flags;
15911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15912                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15913                         if (_ptr_monitor_name) {
15914                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15915                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15916                         } else {
15917                                 r->monitor_name = NULL;
15918                         }
15919                         ndr->flags = _flags_save_string;
15920                 }
15921                 {
15922                         uint32_t _flags_save_string = ndr->flags;
15923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15924                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15925                         if (_ptr_description) {
15926                                 NDR_PULL_ALLOC(ndr, r->description);
15927                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15928                         } else {
15929                                 r->description = NULL;
15930                         }
15931                         ndr->flags = _flags_save_string;
15932                 }
15933                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15935         }
15936         if (ndr_flags & NDR_BUFFERS) {
15937                 {
15938                         uint32_t _flags_save_string = ndr->flags;
15939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15940                         if (r->port_name) {
15941                                 uint32_t _relative_save_offset;
15942                                 _relative_save_offset = ndr->offset;
15943                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15944                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15945                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15946                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15947                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15948                                 ndr->offset = _relative_save_offset;
15949                         }
15950                         ndr->flags = _flags_save_string;
15951                 }
15952                 {
15953                         uint32_t _flags_save_string = ndr->flags;
15954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15955                         if (r->monitor_name) {
15956                                 uint32_t _relative_save_offset;
15957                                 _relative_save_offset = ndr->offset;
15958                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15959                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15960                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15961                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15962                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15963                                 ndr->offset = _relative_save_offset;
15964                         }
15965                         ndr->flags = _flags_save_string;
15966                 }
15967                 {
15968                         uint32_t _flags_save_string = ndr->flags;
15969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15970                         if (r->description) {
15971                                 uint32_t _relative_save_offset;
15972                                 _relative_save_offset = ndr->offset;
15973                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15974                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15975                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15976                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15977                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15978                                 ndr->offset = _relative_save_offset;
15979                         }
15980                         ndr->flags = _flags_save_string;
15981                 }
15982         }
15983         return NDR_ERR_SUCCESS;
15984 }
15985
15986 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15987 {
15988         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15989         ndr->depth++;
15990         ndr_print_ptr(ndr, "port_name", r->port_name);
15991         ndr->depth++;
15992         if (r->port_name) {
15993                 ndr_print_string(ndr, "port_name", r->port_name);
15994         }
15995         ndr->depth--;
15996         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15997         ndr->depth++;
15998         if (r->monitor_name) {
15999                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16000         }
16001         ndr->depth--;
16002         ndr_print_ptr(ndr, "description", r->description);
16003         ndr->depth++;
16004         if (r->description) {
16005                 ndr_print_string(ndr, "description", r->description);
16006         }
16007         ndr->depth--;
16008         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
16009         ndr_print_uint32(ndr, "reserved", r->reserved);
16010         ndr->depth--;
16011 }
16012
16013 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16014 {
16015         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
16016 }
16017
16018 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
16019 {
16020         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16021         return NDR_ERR_SUCCESS;
16022 }
16023
16024 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16025 {
16026         uint32_t v;
16027         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16028         *r = v;
16029         return NDR_ERR_SUCCESS;
16030 }
16031
16032 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16033 {
16034         const char *val = NULL;
16035
16036         switch (r) {
16037                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16038                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16039                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16040                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16041                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16042                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16043                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16044                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16045                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16046                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16047                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16048                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16049                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16050         }
16051         ndr_print_enum(ndr, name, "ENUM", val, r);
16052 }
16053
16054 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16055 {
16056         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16057         return NDR_ERR_SUCCESS;
16058 }
16059
16060 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16061 {
16062         uint32_t v;
16063         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16064         *r = v;
16065         return NDR_ERR_SUCCESS;
16066 }
16067
16068 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16069 {
16070         const char *val = NULL;
16071
16072         switch (r) {
16073                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16074                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16075                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16076         }
16077         ndr_print_enum(ndr, name, "ENUM", val, r);
16078 }
16079
16080 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16081 {
16082         if (ndr_flags & NDR_SCALARS) {
16083                 NDR_CHECK(ndr_push_align(ndr, 4));
16084                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16085                 {
16086                         uint32_t _flags_save_string = ndr->flags;
16087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16088                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16089                         ndr->flags = _flags_save_string;
16090                 }
16091                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16092         }
16093         if (ndr_flags & NDR_BUFFERS) {
16094                 {
16095                         uint32_t _flags_save_string = ndr->flags;
16096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16097                         if (r->status_string) {
16098                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16099                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16100                         }
16101                         ndr->flags = _flags_save_string;
16102                 }
16103         }
16104         return NDR_ERR_SUCCESS;
16105 }
16106
16107 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16108 {
16109         uint32_t _ptr_status_string;
16110         TALLOC_CTX *_mem_save_status_string_0;
16111         if (ndr_flags & NDR_SCALARS) {
16112                 NDR_CHECK(ndr_pull_align(ndr, 4));
16113                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16114                 {
16115                         uint32_t _flags_save_string = ndr->flags;
16116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16117                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16118                         if (_ptr_status_string) {
16119                                 NDR_PULL_ALLOC(ndr, r->status_string);
16120                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16121                         } else {
16122                                 r->status_string = NULL;
16123                         }
16124                         ndr->flags = _flags_save_string;
16125                 }
16126                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16127         }
16128         if (ndr_flags & NDR_BUFFERS) {
16129                 {
16130                         uint32_t _flags_save_string = ndr->flags;
16131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16132                         if (r->status_string) {
16133                                 uint32_t _relative_save_offset;
16134                                 _relative_save_offset = ndr->offset;
16135                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16136                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16137                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16138                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16139                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16140                                 ndr->offset = _relative_save_offset;
16141                         }
16142                         ndr->flags = _flags_save_string;
16143                 }
16144         }
16145         return NDR_ERR_SUCCESS;
16146 }
16147
16148 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16149 {
16150         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16151         ndr->depth++;
16152         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16153         ndr_print_ptr(ndr, "status_string", r->status_string);
16154         ndr->depth++;
16155         if (r->status_string) {
16156                 ndr_print_string(ndr, "status_string", r->status_string);
16157         }
16158         ndr->depth--;
16159         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16160         ndr->depth--;
16161 }
16162
16163 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16164 {
16165         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16166 }
16167
16168 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16169 {
16170         if (ndr_flags & NDR_SCALARS) {
16171                 NDR_CHECK(ndr_push_align(ndr, 4));
16172                 {
16173                         uint32_t _flags_save_string = ndr->flags;
16174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16175                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16176                         ndr->flags = _flags_save_string;
16177                 }
16178                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16179         }
16180         if (ndr_flags & NDR_BUFFERS) {
16181                 {
16182                         uint32_t _flags_save_string = ndr->flags;
16183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16184                         if (r->port_name) {
16185                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16186                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16187                         }
16188                         ndr->flags = _flags_save_string;
16189                 }
16190         }
16191         return NDR_ERR_SUCCESS;
16192 }
16193
16194 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16195 {
16196         uint32_t _ptr_port_name;
16197         TALLOC_CTX *_mem_save_port_name_0;
16198         if (ndr_flags & NDR_SCALARS) {
16199                 NDR_CHECK(ndr_pull_align(ndr, 4));
16200                 {
16201                         uint32_t _flags_save_string = ndr->flags;
16202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16203                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16204                         if (_ptr_port_name) {
16205                                 NDR_PULL_ALLOC(ndr, r->port_name);
16206                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16207                         } else {
16208                                 r->port_name = NULL;
16209                         }
16210                         ndr->flags = _flags_save_string;
16211                 }
16212                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16213         }
16214         if (ndr_flags & NDR_BUFFERS) {
16215                 {
16216                         uint32_t _flags_save_string = ndr->flags;
16217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16218                         if (r->port_name) {
16219                                 uint32_t _relative_save_offset;
16220                                 _relative_save_offset = ndr->offset;
16221                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16222                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16223                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16224                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16225                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16226                                 ndr->offset = _relative_save_offset;
16227                         }
16228                         ndr->flags = _flags_save_string;
16229                 }
16230         }
16231         return NDR_ERR_SUCCESS;
16232 }
16233
16234 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16235 {
16236         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16237         ndr->depth++;
16238         ndr_print_ptr(ndr, "port_name", r->port_name);
16239         ndr->depth++;
16240         if (r->port_name) {
16241                 ndr_print_string(ndr, "port_name", r->port_name);
16242         }
16243         ndr->depth--;
16244         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16245         ndr->depth--;
16246 }
16247
16248 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16249 {
16250         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16251 }
16252
16253 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16254 {
16255         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16256         if (ndr_flags & NDR_SCALARS) {
16257                 int level = ndr_push_get_switch_value(ndr, r);
16258                 switch (level) {
16259                         case 1: {
16260                                 NDR_CHECK(ndr_push_align(ndr, 4));
16261                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16262                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16263                         break; }
16264
16265                         case 2: {
16266                                 NDR_CHECK(ndr_push_align(ndr, 4));
16267                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16268                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16269                         break; }
16270
16271                         case 3: {
16272                                 NDR_CHECK(ndr_push_align(ndr, 4));
16273                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16274                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16275                         break; }
16276
16277                         case 0xff: {
16278                                 NDR_CHECK(ndr_push_align(ndr, 4));
16279                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16280                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16281                         break; }
16282
16283                         default: {
16284                         break; }
16285
16286                 }
16287         }
16288         if (ndr_flags & NDR_BUFFERS) {
16289                 int level = ndr_push_get_switch_value(ndr, r);
16290                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16291                 switch (level) {
16292                         case 1:
16293                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16294                         break;
16295
16296                         case 2:
16297                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16298                         break;
16299
16300                         case 3:
16301                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16302                         break;
16303
16304                         case 0xff:
16305                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16306                         break;
16307
16308                         default:
16309                         break;
16310
16311                 }
16312         }
16313         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16314         return NDR_ERR_SUCCESS;
16315 }
16316
16317 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16318 {
16319         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16320         int level;
16321         level = ndr_pull_get_switch_value(ndr, r);
16322         if (ndr_flags & NDR_SCALARS) {
16323                 switch (level) {
16324                         case 1: {
16325                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16326                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16327                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16328                         break; }
16329
16330                         case 2: {
16331                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16332                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16333                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16334                         break; }
16335
16336                         case 3: {
16337                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16338                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16339                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16340                         break; }
16341
16342                         case 0xff: {
16343                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16344                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16345                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16346                         break; }
16347
16348                         default: {
16349                         break; }
16350
16351                 }
16352         }
16353         if (ndr_flags & NDR_BUFFERS) {
16354                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16355                 switch (level) {
16356                         case 1:
16357                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16358                         break;
16359
16360                         case 2:
16361                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16362                         break;
16363
16364                         case 3:
16365                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16366                         break;
16367
16368                         case 0xff:
16369                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16370                         break;
16371
16372                         default:
16373                         break;
16374
16375                 }
16376         }
16377         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16378         return NDR_ERR_SUCCESS;
16379 }
16380
16381 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16382 {
16383         int level;
16384         level = ndr_print_get_switch_value(ndr, r);
16385         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16386         switch (level) {
16387                 case 1:
16388                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16389                 break;
16390
16391                 case 2:
16392                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16393                 break;
16394
16395                 case 3:
16396                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16397                 break;
16398
16399                 case 0xff:
16400                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16401                 break;
16402
16403                 default:
16404                 break;
16405
16406         }
16407 }
16408
16409 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16410 {
16411         if (ndr_flags & NDR_SCALARS) {
16412                 NDR_CHECK(ndr_push_align(ndr, 4));
16413                 {
16414                         uint32_t _flags_save_string = ndr->flags;
16415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16416                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16417                         ndr->flags = _flags_save_string;
16418                 }
16419         }
16420         if (ndr_flags & NDR_BUFFERS) {
16421                 {
16422                         uint32_t _flags_save_string = ndr->flags;
16423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16424                         if (r->monitor_name) {
16425                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16426                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16427                         }
16428                         ndr->flags = _flags_save_string;
16429                 }
16430         }
16431         return NDR_ERR_SUCCESS;
16432 }
16433
16434 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16435 {
16436         uint32_t _ptr_monitor_name;
16437         TALLOC_CTX *_mem_save_monitor_name_0;
16438         if (ndr_flags & NDR_SCALARS) {
16439                 NDR_CHECK(ndr_pull_align(ndr, 4));
16440                 {
16441                         uint32_t _flags_save_string = ndr->flags;
16442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16443                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16444                         if (_ptr_monitor_name) {
16445                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16446                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16447                         } else {
16448                                 r->monitor_name = NULL;
16449                         }
16450                         ndr->flags = _flags_save_string;
16451                 }
16452         }
16453         if (ndr_flags & NDR_BUFFERS) {
16454                 {
16455                         uint32_t _flags_save_string = ndr->flags;
16456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16457                         if (r->monitor_name) {
16458                                 uint32_t _relative_save_offset;
16459                                 _relative_save_offset = ndr->offset;
16460                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16461                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16462                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16463                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16464                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16465                                 ndr->offset = _relative_save_offset;
16466                         }
16467                         ndr->flags = _flags_save_string;
16468                 }
16469         }
16470         return NDR_ERR_SUCCESS;
16471 }
16472
16473 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16474 {
16475         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16476         ndr->depth++;
16477         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16478         ndr->depth++;
16479         if (r->monitor_name) {
16480                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16481         }
16482         ndr->depth--;
16483         ndr->depth--;
16484 }
16485
16486 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16487 {
16488         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16489 }
16490
16491 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16492 {
16493         if (ndr_flags & NDR_SCALARS) {
16494                 NDR_CHECK(ndr_push_align(ndr, 4));
16495                 {
16496                         uint32_t _flags_save_string = ndr->flags;
16497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16499                         ndr->flags = _flags_save_string;
16500                 }
16501                 {
16502                         uint32_t _flags_save_string = ndr->flags;
16503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16505                         ndr->flags = _flags_save_string;
16506                 }
16507                 {
16508                         uint32_t _flags_save_string = ndr->flags;
16509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16510                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16511                         ndr->flags = _flags_save_string;
16512                 }
16513         }
16514         if (ndr_flags & NDR_BUFFERS) {
16515                 {
16516                         uint32_t _flags_save_string = ndr->flags;
16517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16518                         if (r->monitor_name) {
16519                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16520                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16521                         }
16522                         ndr->flags = _flags_save_string;
16523                 }
16524                 {
16525                         uint32_t _flags_save_string = ndr->flags;
16526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16527                         if (r->environment) {
16528                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16529                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16530                         }
16531                         ndr->flags = _flags_save_string;
16532                 }
16533                 {
16534                         uint32_t _flags_save_string = ndr->flags;
16535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16536                         if (r->dll_name) {
16537                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16538                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16539                         }
16540                         ndr->flags = _flags_save_string;
16541                 }
16542         }
16543         return NDR_ERR_SUCCESS;
16544 }
16545
16546 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16547 {
16548         uint32_t _ptr_monitor_name;
16549         TALLOC_CTX *_mem_save_monitor_name_0;
16550         uint32_t _ptr_environment;
16551         TALLOC_CTX *_mem_save_environment_0;
16552         uint32_t _ptr_dll_name;
16553         TALLOC_CTX *_mem_save_dll_name_0;
16554         if (ndr_flags & NDR_SCALARS) {
16555                 NDR_CHECK(ndr_pull_align(ndr, 4));
16556                 {
16557                         uint32_t _flags_save_string = ndr->flags;
16558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16560                         if (_ptr_monitor_name) {
16561                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16563                         } else {
16564                                 r->monitor_name = NULL;
16565                         }
16566                         ndr->flags = _flags_save_string;
16567                 }
16568                 {
16569                         uint32_t _flags_save_string = ndr->flags;
16570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16571                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16572                         if (_ptr_environment) {
16573                                 NDR_PULL_ALLOC(ndr, r->environment);
16574                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16575                         } else {
16576                                 r->environment = NULL;
16577                         }
16578                         ndr->flags = _flags_save_string;
16579                 }
16580                 {
16581                         uint32_t _flags_save_string = ndr->flags;
16582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16583                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16584                         if (_ptr_dll_name) {
16585                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16586                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16587                         } else {
16588                                 r->dll_name = NULL;
16589                         }
16590                         ndr->flags = _flags_save_string;
16591                 }
16592         }
16593         if (ndr_flags & NDR_BUFFERS) {
16594                 {
16595                         uint32_t _flags_save_string = ndr->flags;
16596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16597                         if (r->monitor_name) {
16598                                 uint32_t _relative_save_offset;
16599                                 _relative_save_offset = ndr->offset;
16600                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16601                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16602                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16603                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16604                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16605                                 ndr->offset = _relative_save_offset;
16606                         }
16607                         ndr->flags = _flags_save_string;
16608                 }
16609                 {
16610                         uint32_t _flags_save_string = ndr->flags;
16611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16612                         if (r->environment) {
16613                                 uint32_t _relative_save_offset;
16614                                 _relative_save_offset = ndr->offset;
16615                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16616                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16617                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16618                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16619                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16620                                 ndr->offset = _relative_save_offset;
16621                         }
16622                         ndr->flags = _flags_save_string;
16623                 }
16624                 {
16625                         uint32_t _flags_save_string = ndr->flags;
16626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16627                         if (r->dll_name) {
16628                                 uint32_t _relative_save_offset;
16629                                 _relative_save_offset = ndr->offset;
16630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16631                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16632                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16633                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16635                                 ndr->offset = _relative_save_offset;
16636                         }
16637                         ndr->flags = _flags_save_string;
16638                 }
16639         }
16640         return NDR_ERR_SUCCESS;
16641 }
16642
16643 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16644 {
16645         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16646         ndr->depth++;
16647         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16648         ndr->depth++;
16649         if (r->monitor_name) {
16650                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16651         }
16652         ndr->depth--;
16653         ndr_print_ptr(ndr, "environment", r->environment);
16654         ndr->depth++;
16655         if (r->environment) {
16656                 ndr_print_string(ndr, "environment", r->environment);
16657         }
16658         ndr->depth--;
16659         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16660         ndr->depth++;
16661         if (r->dll_name) {
16662                 ndr_print_string(ndr, "dll_name", r->dll_name);
16663         }
16664         ndr->depth--;
16665         ndr->depth--;
16666 }
16667
16668 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16669 {
16670         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16671 }
16672
16673 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16674 {
16675         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16676         if (ndr_flags & NDR_SCALARS) {
16677                 int level = ndr_push_get_switch_value(ndr, r);
16678                 switch (level) {
16679                         case 1: {
16680                                 NDR_CHECK(ndr_push_align(ndr, 4));
16681                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16682                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16683                         break; }
16684
16685                         case 2: {
16686                                 NDR_CHECK(ndr_push_align(ndr, 4));
16687                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16688                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16689                         break; }
16690
16691                         default: {
16692                         break; }
16693
16694                 }
16695         }
16696         if (ndr_flags & NDR_BUFFERS) {
16697                 int level = ndr_push_get_switch_value(ndr, r);
16698                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16699                 switch (level) {
16700                         case 1:
16701                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16702                         break;
16703
16704                         case 2:
16705                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16706                         break;
16707
16708                         default:
16709                         break;
16710
16711                 }
16712         }
16713         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16714         return NDR_ERR_SUCCESS;
16715 }
16716
16717 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16718 {
16719         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16720         int level;
16721         level = ndr_pull_get_switch_value(ndr, r);
16722         if (ndr_flags & NDR_SCALARS) {
16723                 switch (level) {
16724                         case 1: {
16725                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16726                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16727                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16728                         break; }
16729
16730                         case 2: {
16731                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16732                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16733                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16734                         break; }
16735
16736                         default: {
16737                         break; }
16738
16739                 }
16740         }
16741         if (ndr_flags & NDR_BUFFERS) {
16742                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16743                 switch (level) {
16744                         case 1:
16745                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16746                         break;
16747
16748                         case 2:
16749                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16750                         break;
16751
16752                         default:
16753                         break;
16754
16755                 }
16756         }
16757         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16758         return NDR_ERR_SUCCESS;
16759 }
16760
16761 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16762 {
16763         int level;
16764         level = ndr_print_get_switch_value(ndr, r);
16765         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16766         switch (level) {
16767                 case 1:
16768                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16769                 break;
16770
16771                 case 2:
16772                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16773                 break;
16774
16775                 default:
16776                 break;
16777
16778         }
16779 }
16780
16781 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16782 {
16783         if (ndr_flags & NDR_SCALARS) {
16784                 NDR_CHECK(ndr_push_align(ndr, 4));
16785                 {
16786                         uint32_t _flags_save_string = ndr->flags;
16787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16788                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16789                         ndr->flags = _flags_save_string;
16790                 }
16791         }
16792         if (ndr_flags & NDR_BUFFERS) {
16793                 {
16794                         uint32_t _flags_save_string = ndr->flags;
16795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16796                         if (r->name_array) {
16797                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16798                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16799                         }
16800                         ndr->flags = _flags_save_string;
16801                 }
16802         }
16803         return NDR_ERR_SUCCESS;
16804 }
16805
16806 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16807 {
16808         uint32_t _ptr_name_array;
16809         TALLOC_CTX *_mem_save_name_array_0;
16810         if (ndr_flags & NDR_SCALARS) {
16811                 NDR_CHECK(ndr_pull_align(ndr, 4));
16812                 {
16813                         uint32_t _flags_save_string = ndr->flags;
16814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16816                         if (_ptr_name_array) {
16817                                 NDR_PULL_ALLOC(ndr, r->name_array);
16818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16819                         } else {
16820                                 r->name_array = NULL;
16821                         }
16822                         ndr->flags = _flags_save_string;
16823                 }
16824         }
16825         if (ndr_flags & NDR_BUFFERS) {
16826                 {
16827                         uint32_t _flags_save_string = ndr->flags;
16828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16829                         if (r->name_array) {
16830                                 uint32_t _relative_save_offset;
16831                                 _relative_save_offset = ndr->offset;
16832                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16833                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16834                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16835                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16836                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16837                                 ndr->offset = _relative_save_offset;
16838                         }
16839                         ndr->flags = _flags_save_string;
16840                 }
16841         }
16842         return NDR_ERR_SUCCESS;
16843 }
16844
16845 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16846 {
16847         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16848         ndr->depth++;
16849         ndr_print_ptr(ndr, "name_array", r->name_array);
16850         ndr->depth++;
16851         if (r->name_array) {
16852                 ndr_print_string(ndr, "name_array", r->name_array);
16853         }
16854         ndr->depth--;
16855         ndr->depth--;
16856 }
16857
16858 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16859 {
16860         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16861 }
16862
16863 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16864 {
16865         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16866         if (ndr_flags & NDR_SCALARS) {
16867                 int level = ndr_push_get_switch_value(ndr, r);
16868                 switch (level) {
16869                         case 1: {
16870                                 NDR_CHECK(ndr_push_align(ndr, 4));
16871                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16872                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16873                         break; }
16874
16875                         default: {
16876                         break; }
16877
16878                 }
16879         }
16880         if (ndr_flags & NDR_BUFFERS) {
16881                 int level = ndr_push_get_switch_value(ndr, r);
16882                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16883                 switch (level) {
16884                         case 1:
16885                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16886                         break;
16887
16888                         default:
16889                         break;
16890
16891                 }
16892         }
16893         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16894         return NDR_ERR_SUCCESS;
16895 }
16896
16897 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16898 {
16899         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16900         int level;
16901         level = ndr_pull_get_switch_value(ndr, r);
16902         if (ndr_flags & NDR_SCALARS) {
16903                 switch (level) {
16904                         case 1: {
16905                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16906                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16907                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16908                         break; }
16909
16910                         default: {
16911                         break; }
16912
16913                 }
16914         }
16915         if (ndr_flags & NDR_BUFFERS) {
16916                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16917                 switch (level) {
16918                         case 1:
16919                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16920                         break;
16921
16922                         default:
16923                         break;
16924
16925                 }
16926         }
16927         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16928         return NDR_ERR_SUCCESS;
16929 }
16930
16931 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16932 {
16933         int level;
16934         level = ndr_print_get_switch_value(ndr, r);
16935         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16936         switch (level) {
16937                 case 1:
16938                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16939                 break;
16940
16941                 default:
16942                 break;
16943
16944         }
16945 }
16946
16947 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16948 {
16949         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16950         return NDR_ERR_SUCCESS;
16951 }
16952
16953 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16954 {
16955         uint32_t v;
16956         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16957         *r = v;
16958         return NDR_ERR_SUCCESS;
16959 }
16960
16961 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16962 {
16963         ndr_print_uint32(ndr, name, r);
16964         ndr->depth++;
16965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16968         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16985         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16986         ndr->depth--;
16987 }
16988
16989 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
16990 {
16991         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16992         return NDR_ERR_SUCCESS;
16993 }
16994
16995 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
16996 {
16997         uint16_t v;
16998         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16999         *r = v;
17000         return NDR_ERR_SUCCESS;
17001 }
17002
17003 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
17004 {
17005         const char *val = NULL;
17006
17007         switch (r) {
17008                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
17009                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
17010                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
17011                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
17012                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
17013                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
17014                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17015                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
17016                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
17017                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
17018                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
17019                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
17020                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17021                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
17022                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
17023                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
17024                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
17025                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
17026                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
17027                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
17028                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
17029                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
17030                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
17031                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
17032         }
17033         ndr_print_enum(ndr, name, "ENUM", val, r);
17034 }
17035
17036 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
17037 {
17038         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17039         return NDR_ERR_SUCCESS;
17040 }
17041
17042 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
17043 {
17044         uint16_t v;
17045         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17046         *r = v;
17047         return NDR_ERR_SUCCESS;
17048 }
17049
17050 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
17051 {
17052         const char *val = NULL;
17053
17054         switch (r) {
17055                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
17056                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
17057                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
17058                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
17059                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
17060                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
17061                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
17062                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
17063                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
17064                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17065                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
17066                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
17067                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17068                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
17069                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
17070                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
17071                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
17072                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
17073                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
17074                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
17075                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
17076                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
17077                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
17078                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
17079                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
17080                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
17081                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
17082                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
17083         }
17084         ndr_print_enum(ndr, name, "ENUM", val, r);
17085 }
17086
17087 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17088 {
17089         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17090         return NDR_ERR_SUCCESS;
17091 }
17092
17093 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17094 {
17095         uint16_t v;
17096         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17097         *r = v;
17098         return NDR_ERR_SUCCESS;
17099 }
17100
17101 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17102 {
17103         const char *val = NULL;
17104
17105         switch (r) {
17106                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17107                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17108         }
17109         ndr_print_enum(ndr, name, "ENUM", val, r);
17110 }
17111
17112 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
17113 {
17114         if (ndr_flags & NDR_SCALARS) {
17115                 int level = ndr_push_get_switch_value(ndr, r);
17116                 switch (level) {
17117                         case PRINTER_NOTIFY_TYPE: {
17118                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17119                         break; }
17120
17121                         case JOB_NOTIFY_TYPE: {
17122                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17123                         break; }
17124
17125                         default: {
17126                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17127                         break; }
17128
17129                 }
17130         }
17131         if (ndr_flags & NDR_BUFFERS) {
17132                 int level = ndr_push_get_switch_value(ndr, r);
17133                 switch (level) {
17134                         case PRINTER_NOTIFY_TYPE:
17135                         break;
17136
17137                         case JOB_NOTIFY_TYPE:
17138                         break;
17139
17140                         default:
17141                         break;
17142
17143                 }
17144         }
17145         return NDR_ERR_SUCCESS;
17146 }
17147
17148 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
17149 {
17150         int level;
17151         level = ndr_pull_get_switch_value(ndr, r);
17152         if (ndr_flags & NDR_SCALARS) {
17153                 switch (level) {
17154                         case PRINTER_NOTIFY_TYPE: {
17155                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17156                         break; }
17157
17158                         case JOB_NOTIFY_TYPE: {
17159                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17160                         break; }
17161
17162                         default: {
17163                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17164                         break; }
17165
17166                 }
17167         }
17168         if (ndr_flags & NDR_BUFFERS) {
17169                 switch (level) {
17170                         case PRINTER_NOTIFY_TYPE:
17171                         break;
17172
17173                         case JOB_NOTIFY_TYPE:
17174                         break;
17175
17176                         default:
17177                         break;
17178
17179                 }
17180         }
17181         return NDR_ERR_SUCCESS;
17182 }
17183
17184 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17185 {
17186         uint32_t cntr_fields_1;
17187         if (ndr_flags & NDR_SCALARS) {
17188                 NDR_CHECK(ndr_push_align(ndr, 4));
17189                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17190                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17195         }
17196         if (ndr_flags & NDR_BUFFERS) {
17197                 if (r->fields) {
17198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17199                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17200                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17201                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17202                         }
17203                 }
17204         }
17205         return NDR_ERR_SUCCESS;
17206 }
17207
17208 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17209 {
17210         uint32_t _ptr_fields;
17211         uint32_t cntr_fields_1;
17212         TALLOC_CTX *_mem_save_fields_0;
17213         TALLOC_CTX *_mem_save_fields_1;
17214         if (ndr_flags & NDR_SCALARS) {
17215                 NDR_CHECK(ndr_pull_align(ndr, 4));
17216                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17217                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17222                 if (_ptr_fields) {
17223                         NDR_PULL_ALLOC(ndr, r->fields);
17224                 } else {
17225                         r->fields = NULL;
17226                 }
17227         }
17228         if (ndr_flags & NDR_BUFFERS) {
17229                 if (r->fields) {
17230                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17231                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17233                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17234                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17235                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17236                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17237                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17238                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17239                         }
17240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17241                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17242                 }
17243                 if (r->fields) {
17244                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17245                 }
17246         }
17247         return NDR_ERR_SUCCESS;
17248 }
17249
17250 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17251 {
17252         uint32_t cntr_fields_1;
17253         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17254         ndr->depth++;
17255         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17256         ndr_print_uint16(ndr, "u1", r->u1);
17257         ndr_print_uint32(ndr, "u2", r->u2);
17258         ndr_print_uint32(ndr, "u3", r->u3);
17259         ndr_print_uint32(ndr, "count", r->count);
17260         ndr_print_ptr(ndr, "fields", r->fields);
17261         ndr->depth++;
17262         if (r->fields) {
17263                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17264                 ndr->depth++;
17265                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17266                         char *idx_1=NULL;
17267                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17268                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
17269                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
17270                                 free(idx_1);
17271                         }
17272                 }
17273                 ndr->depth--;
17274         }
17275         ndr->depth--;
17276         ndr->depth--;
17277 }
17278
17279 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17280 {
17281         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17282         return NDR_ERR_SUCCESS;
17283 }
17284
17285 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17286 {
17287         uint32_t v;
17288         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17289         *r = v;
17290         return NDR_ERR_SUCCESS;
17291 }
17292
17293 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17294 {
17295         ndr_print_uint32(ndr, name, r);
17296         ndr->depth++;
17297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17298         ndr->depth--;
17299 }
17300
17301 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17302 {
17303         uint32_t cntr_types_1;
17304         if (ndr_flags & NDR_SCALARS) {
17305                 NDR_CHECK(ndr_push_align(ndr, 4));
17306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17307                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17310         }
17311         if (ndr_flags & NDR_BUFFERS) {
17312                 if (r->types) {
17313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17314                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17315                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17316                         }
17317                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17318                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17319                         }
17320                 }
17321         }
17322         return NDR_ERR_SUCCESS;
17323 }
17324
17325 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17326 {
17327         uint32_t _ptr_types;
17328         uint32_t cntr_types_1;
17329         TALLOC_CTX *_mem_save_types_0;
17330         TALLOC_CTX *_mem_save_types_1;
17331         if (ndr_flags & NDR_SCALARS) {
17332                 NDR_CHECK(ndr_pull_align(ndr, 4));
17333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17334                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17337                 if (_ptr_types) {
17338                         NDR_PULL_ALLOC(ndr, r->types);
17339                 } else {
17340                         r->types = NULL;
17341                 }
17342         }
17343         if (ndr_flags & NDR_BUFFERS) {
17344                 if (r->types) {
17345                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17346                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17347                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17348                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17349                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17350                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17351                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17352                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17353                         }
17354                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17355                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17356                         }
17357                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17359                 }
17360                 if (r->types) {
17361                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17362                 }
17363         }
17364         return NDR_ERR_SUCCESS;
17365 }
17366
17367 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17368 {
17369         uint32_t cntr_types_1;
17370         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17371         ndr->depth++;
17372         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17373         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17374         ndr_print_uint32(ndr, "count", r->count);
17375         ndr_print_ptr(ndr, "types", r->types);
17376         ndr->depth++;
17377         if (r->types) {
17378                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17379                 ndr->depth++;
17380                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17381                         char *idx_1=NULL;
17382                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17383                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17384                                 free(idx_1);
17385                         }
17386                 }
17387                 ndr->depth--;
17388         }
17389         ndr->depth--;
17390         ndr->depth--;
17391 }
17392
17393 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17394 {
17395         if (ndr_flags & NDR_SCALARS) {
17396                 NDR_CHECK(ndr_push_align(ndr, 4));
17397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17399         }
17400         if (ndr_flags & NDR_BUFFERS) {
17401                 if (r->string) {
17402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17403                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17404                 }
17405         }
17406         return NDR_ERR_SUCCESS;
17407 }
17408
17409 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17410 {
17411         uint32_t _ptr_string;
17412         TALLOC_CTX *_mem_save_string_0;
17413         if (ndr_flags & NDR_SCALARS) {
17414                 NDR_CHECK(ndr_pull_align(ndr, 4));
17415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17417                 if (_ptr_string) {
17418                         NDR_PULL_ALLOC(ndr, r->string);
17419                 } else {
17420                         r->string = NULL;
17421                 }
17422         }
17423         if (ndr_flags & NDR_BUFFERS) {
17424                 if (r->string) {
17425                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17426                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17428                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17430                 }
17431                 if (r->string) {
17432                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17433                 }
17434         }
17435         return NDR_ERR_SUCCESS;
17436 }
17437
17438 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17439 {
17440         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17441         ndr->depth++;
17442         ndr_print_uint32(ndr, "size", r->size);
17443         ndr_print_ptr(ndr, "string", r->string);
17444         ndr->depth++;
17445         if (r->string) {
17446                 ndr_print_string(ndr, "string", r->string);
17447         }
17448         ndr->depth--;
17449         ndr->depth--;
17450 }
17451
17452 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17453 {
17454         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17455         return NDR_ERR_SUCCESS;
17456 }
17457
17458 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17459 {
17460         uint32_t v;
17461         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17462         *r = v;
17463         return NDR_ERR_SUCCESS;
17464 }
17465
17466 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17467 {
17468         const char *val = NULL;
17469
17470         switch (r) {
17471                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17472                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17473                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17474                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17475                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17476         }
17477         ndr_print_enum(ndr, name, "ENUM", val, r);
17478 }
17479
17480 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17481 {
17482         if (ndr_flags & NDR_SCALARS) {
17483                 int level = ndr_push_get_switch_value(ndr, r);
17484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17485                 switch (level) {
17486                         case 1: {
17487                                 uint32_t cntr_integer_0;
17488                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17489                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17490                                 }
17491                         break; }
17492
17493                         case 2: {
17494                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17495                         break; }
17496
17497                         case 3: {
17498                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17499                         break; }
17500
17501                         case 4: {
17502                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17503                         break; }
17504
17505                         case 5: {
17506                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17507                         break; }
17508
17509                         default:
17510                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17511                 }
17512         }
17513         if (ndr_flags & NDR_BUFFERS) {
17514                 int level = ndr_push_get_switch_value(ndr, r);
17515                 switch (level) {
17516                         case 1:
17517                         break;
17518
17519                         case 2:
17520                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17521                         break;
17522
17523                         case 3:
17524                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17525                         break;
17526
17527                         case 4:
17528                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17529                         break;
17530
17531                         case 5:
17532                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17533                         break;
17534
17535                         default:
17536                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17537                 }
17538         }
17539         return NDR_ERR_SUCCESS;
17540 }
17541
17542 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17543 {
17544         int level;
17545         uint32_t _level;
17546         level = ndr_pull_get_switch_value(ndr, r);
17547         if (ndr_flags & NDR_SCALARS) {
17548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17549                 if (_level != level) {
17550                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17551                 }
17552                 switch (level) {
17553                         case 1: {
17554                                 uint32_t cntr_integer_0;
17555                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17556                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17557                                 }
17558                         break; }
17559
17560                         case 2: {
17561                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17562                         break; }
17563
17564                         case 3: {
17565                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17566                         break; }
17567
17568                         case 4: {
17569                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17570                         break; }
17571
17572                         case 5: {
17573                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17574                         break; }
17575
17576                         default:
17577                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17578                 }
17579         }
17580         if (ndr_flags & NDR_BUFFERS) {
17581                 switch (level) {
17582                         case 1:
17583                         break;
17584
17585                         case 2:
17586                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17587                         break;
17588
17589                         case 3:
17590                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17591                         break;
17592
17593                         case 4:
17594                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17595                         break;
17596
17597                         case 5:
17598                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17599                         break;
17600
17601                         default:
17602                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17603                 }
17604         }
17605         return NDR_ERR_SUCCESS;
17606 }
17607
17608 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17609 {
17610         int level;
17611         uint32_t cntr_integer_0;
17612         level = ndr_print_get_switch_value(ndr, r);
17613         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17614         switch (level) {
17615                 case 1:
17616                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17617                         ndr->depth++;
17618                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17619                                 char *idx_0=NULL;
17620                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17621                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17622                                         free(idx_0);
17623                                 }
17624                         }
17625                         ndr->depth--;
17626                 break;
17627
17628                 case 2:
17629                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17630                 break;
17631
17632                 case 3:
17633                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17634                 break;
17635
17636                 case 4:
17637                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17638                 break;
17639
17640                 case 5:
17641                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17642                 break;
17643
17644                 default:
17645                         ndr_print_bad_level(ndr, name, level);
17646         }
17647 }
17648
17649 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17650 {
17651         if (ndr_flags & NDR_SCALARS) {
17652                 NDR_CHECK(ndr_push_align(ndr, 4));
17653                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17654                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
17655                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17656                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17658                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17659                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17660         }
17661         if (ndr_flags & NDR_BUFFERS) {
17662                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17663         }
17664         return NDR_ERR_SUCCESS;
17665 }
17666
17667 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17668 {
17669         if (ndr_flags & NDR_SCALARS) {
17670                 NDR_CHECK(ndr_pull_align(ndr, 4));
17671                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17672                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
17673                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17674                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17676                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17677                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17678         }
17679         if (ndr_flags & NDR_BUFFERS) {
17680                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17681         }
17682         return NDR_ERR_SUCCESS;
17683 }
17684
17685 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17686 {
17687         ndr_print_struct(ndr, name, "spoolss_Notify");
17688         ndr->depth++;
17689         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17690         ndr_print_set_switch_value(ndr, &r->field, r->type);
17691         ndr_print_spoolss_Field(ndr, "field", &r->field);
17692         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17693         ndr_print_uint32(ndr, "job_id", r->job_id);
17694         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17695         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17696         ndr->depth--;
17697 }
17698
17699 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17700 {
17701         uint32_t cntr_notifies_0;
17702         if (ndr_flags & NDR_SCALARS) {
17703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17704                 NDR_CHECK(ndr_push_align(ndr, 4));
17705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17708                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17709                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17710                 }
17711         }
17712         if (ndr_flags & NDR_BUFFERS) {
17713                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17714                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17715                 }
17716         }
17717         return NDR_ERR_SUCCESS;
17718 }
17719
17720 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17721 {
17722         uint32_t cntr_notifies_0;
17723         TALLOC_CTX *_mem_save_notifies_0;
17724         if (ndr_flags & NDR_SCALARS) {
17725                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17726                 NDR_CHECK(ndr_pull_align(ndr, 4));
17727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17730                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17731                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17732                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17733                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17734                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17735                 }
17736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17737                 if (r->notifies) {
17738                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17739                 }
17740         }
17741         if (ndr_flags & NDR_BUFFERS) {
17742                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17743                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17744                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17745                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17746                 }
17747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17748         }
17749         return NDR_ERR_SUCCESS;
17750 }
17751
17752 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17753 {
17754         uint32_t cntr_notifies_0;
17755         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17756         ndr->depth++;
17757         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17758         ndr_print_uint32(ndr, "flags", r->flags);
17759         ndr_print_uint32(ndr, "count", r->count);
17760         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17761         ndr->depth++;
17762         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17763                 char *idx_0=NULL;
17764                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17765                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17766                         free(idx_0);
17767                 }
17768         }
17769         ndr->depth--;
17770         ndr->depth--;
17771 }
17772
17773 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17774 {
17775         if (ndr_flags & NDR_SCALARS) {
17776                 int level = ndr_push_get_switch_value(ndr, r);
17777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17778                 switch (level) {
17779                         case 0: {
17780                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17781                         break; }
17782
17783                         default:
17784                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17785                 }
17786         }
17787         if (ndr_flags & NDR_BUFFERS) {
17788                 int level = ndr_push_get_switch_value(ndr, r);
17789                 switch (level) {
17790                         case 0:
17791                                 if (r->info0) {
17792                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17793                                 }
17794                         break;
17795
17796                         default:
17797                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17798                 }
17799         }
17800         return NDR_ERR_SUCCESS;
17801 }
17802
17803 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17804 {
17805         int level;
17806         uint32_t _level;
17807         TALLOC_CTX *_mem_save_info0_0;
17808         level = ndr_pull_get_switch_value(ndr, r);
17809         if (ndr_flags & NDR_SCALARS) {
17810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17811                 if (_level != level) {
17812                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17813                 }
17814                 switch (level) {
17815                         case 0: {
17816                                 uint32_t _ptr_info0;
17817                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17818                                 if (_ptr_info0) {
17819                                         NDR_PULL_ALLOC(ndr, r->info0);
17820                                 } else {
17821                                         r->info0 = NULL;
17822                                 }
17823                         break; }
17824
17825                         default:
17826                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17827                 }
17828         }
17829         if (ndr_flags & NDR_BUFFERS) {
17830                 switch (level) {
17831                         case 0:
17832                                 if (r->info0) {
17833                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17834                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17835                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17836                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17837                                 }
17838                         break;
17839
17840                         default:
17841                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17842                 }
17843         }
17844         return NDR_ERR_SUCCESS;
17845 }
17846
17847 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17848 {
17849         int level;
17850         level = ndr_print_get_switch_value(ndr, r);
17851         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17852         switch (level) {
17853                 case 0:
17854                         ndr_print_ptr(ndr, "info0", r->info0);
17855                         ndr->depth++;
17856                         if (r->info0) {
17857                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17858                         }
17859                         ndr->depth--;
17860                 break;
17861
17862                 default:
17863                         ndr_print_bad_level(ndr, name, level);
17864         }
17865 }
17866
17867 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17868 {
17869         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17870         return NDR_ERR_SUCCESS;
17871 }
17872
17873 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17874 {
17875         uint32_t v;
17876         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17877         *r = v;
17878         return NDR_ERR_SUCCESS;
17879 }
17880
17881 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17882 {
17883         ndr_print_uint32(ndr, name, r);
17884         ndr->depth++;
17885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17888         ndr->depth--;
17889 }
17890
17891 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17892 {
17893         if (ndr_flags & NDR_SCALARS) {
17894                 NDR_CHECK(ndr_push_align(ndr, 4));
17895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17899                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17900                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17901                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17902         }
17903         if (ndr_flags & NDR_BUFFERS) {
17904                 if (r->client) {
17905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17908                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17909                 }
17910                 if (r->user) {
17911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17913                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17914                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17915                 }
17916         }
17917         return NDR_ERR_SUCCESS;
17918 }
17919
17920 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17921 {
17922         uint32_t _ptr_client;
17923         TALLOC_CTX *_mem_save_client_0;
17924         uint32_t _ptr_user;
17925         TALLOC_CTX *_mem_save_user_0;
17926         if (ndr_flags & NDR_SCALARS) {
17927                 NDR_CHECK(ndr_pull_align(ndr, 4));
17928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17930                 if (_ptr_client) {
17931                         NDR_PULL_ALLOC(ndr, r->client);
17932                 } else {
17933                         r->client = NULL;
17934                 }
17935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17936                 if (_ptr_user) {
17937                         NDR_PULL_ALLOC(ndr, r->user);
17938                 } else {
17939                         r->user = NULL;
17940                 }
17941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17942                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17943                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17944                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17945         }
17946         if (ndr_flags & NDR_BUFFERS) {
17947                 if (r->client) {
17948                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17949                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17951                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17952                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17953                                 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));
17954                         }
17955                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17956                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17958                 }
17959                 if (r->user) {
17960                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17961                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17962                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17963                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17964                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17965                                 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));
17966                         }
17967                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17968                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17970                 }
17971         }
17972         return NDR_ERR_SUCCESS;
17973 }
17974
17975 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17976 {
17977         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17978         ndr->depth++;
17979         ndr_print_uint32(ndr, "size", r->size);
17980         ndr_print_ptr(ndr, "client", r->client);
17981         ndr->depth++;
17982         if (r->client) {
17983                 ndr_print_string(ndr, "client", r->client);
17984         }
17985         ndr->depth--;
17986         ndr_print_ptr(ndr, "user", r->user);
17987         ndr->depth++;
17988         if (r->user) {
17989                 ndr_print_string(ndr, "user", r->user);
17990         }
17991         ndr->depth--;
17992         ndr_print_uint32(ndr, "build", r->build);
17993         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17994         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17995         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17996         ndr->depth--;
17997 }
17998
17999 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
18000 {
18001         if (ndr_flags & NDR_SCALARS) {
18002                 NDR_CHECK(ndr_push_align(ndr, 4));
18003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
18004         }
18005         if (ndr_flags & NDR_BUFFERS) {
18006         }
18007         return NDR_ERR_SUCCESS;
18008 }
18009
18010 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
18011 {
18012         if (ndr_flags & NDR_SCALARS) {
18013                 NDR_CHECK(ndr_pull_align(ndr, 4));
18014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
18015         }
18016         if (ndr_flags & NDR_BUFFERS) {
18017         }
18018         return NDR_ERR_SUCCESS;
18019 }
18020
18021 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
18022 {
18023         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
18024         ndr->depth++;
18025         ndr_print_uint32(ndr, "not_used", r->not_used);
18026         ndr->depth--;
18027 }
18028
18029 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
18030 {
18031         if (ndr_flags & NDR_SCALARS) {
18032                 NDR_CHECK(ndr_push_align(ndr, 4));
18033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
18036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18039                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18040                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18041                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18042                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
18043         }
18044         if (ndr_flags & NDR_BUFFERS) {
18045                 if (r->client) {
18046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18049                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18050                 }
18051                 if (r->user) {
18052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18055                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18056                 }
18057         }
18058         return NDR_ERR_SUCCESS;
18059 }
18060
18061 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
18062 {
18063         uint32_t _ptr_client;
18064         TALLOC_CTX *_mem_save_client_0;
18065         uint32_t _ptr_user;
18066         TALLOC_CTX *_mem_save_user_0;
18067         if (ndr_flags & NDR_SCALARS) {
18068                 NDR_CHECK(ndr_pull_align(ndr, 4));
18069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
18072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18073                 if (_ptr_client) {
18074                         NDR_PULL_ALLOC(ndr, r->client);
18075                 } else {
18076                         r->client = NULL;
18077                 }
18078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18079                 if (_ptr_user) {
18080                         NDR_PULL_ALLOC(ndr, r->user);
18081                 } else {
18082                         r->user = NULL;
18083                 }
18084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18085                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18086                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18087                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18088                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
18089         }
18090         if (ndr_flags & NDR_BUFFERS) {
18091                 if (r->client) {
18092                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18093                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18094                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18095                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18096                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18097                                 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));
18098                         }
18099                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18100                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18102                 }
18103                 if (r->user) {
18104                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18105                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18108                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18109                                 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));
18110                         }
18111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18112                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18114                 }
18115         }
18116         return NDR_ERR_SUCCESS;
18117 }
18118
18119 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
18120 {
18121         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
18122         ndr->depth++;
18123         ndr_print_uint32(ndr, "size", r->size);
18124         ndr_print_uint32(ndr, "flags", r->flags);
18125         ndr_print_uint32(ndr, "size2", r->size2);
18126         ndr_print_ptr(ndr, "client", r->client);
18127         ndr->depth++;
18128         if (r->client) {
18129                 ndr_print_string(ndr, "client", r->client);
18130         }
18131         ndr->depth--;
18132         ndr_print_ptr(ndr, "user", r->user);
18133         ndr->depth++;
18134         if (r->user) {
18135                 ndr_print_string(ndr, "user", r->user);
18136         }
18137         ndr->depth--;
18138         ndr_print_uint32(ndr, "build", r->build);
18139         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18140         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18141         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18142         ndr_print_udlong(ndr, "reserved", r->reserved);
18143         ndr->depth--;
18144 }
18145
18146 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18147 {
18148         if (ndr_flags & NDR_SCALARS) {
18149                 int level = ndr_push_get_switch_value(ndr, r);
18150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18151                 switch (level) {
18152                         case 1: {
18153                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18154                         break; }
18155
18156                         case 2: {
18157                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18158                         break; }
18159
18160                         case 3: {
18161                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18162                         break; }
18163
18164                         default:
18165                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18166                 }
18167         }
18168         if (ndr_flags & NDR_BUFFERS) {
18169                 int level = ndr_push_get_switch_value(ndr, r);
18170                 switch (level) {
18171                         case 1:
18172                                 if (r->level1) {
18173                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18174                                 }
18175                         break;
18176
18177                         case 2:
18178                                 if (r->level2) {
18179                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18180                                 }
18181                         break;
18182
18183                         case 3:
18184                                 if (r->level3) {
18185                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18186                                 }
18187                         break;
18188
18189                         default:
18190                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18191                 }
18192         }
18193         return NDR_ERR_SUCCESS;
18194 }
18195
18196 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18197 {
18198         int level;
18199         uint32_t _level;
18200         TALLOC_CTX *_mem_save_level1_0;
18201         TALLOC_CTX *_mem_save_level2_0;
18202         TALLOC_CTX *_mem_save_level3_0;
18203         level = ndr_pull_get_switch_value(ndr, r);
18204         if (ndr_flags & NDR_SCALARS) {
18205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18206                 if (_level != level) {
18207                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18208                 }
18209                 switch (level) {
18210                         case 1: {
18211                                 uint32_t _ptr_level1;
18212                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18213                                 if (_ptr_level1) {
18214                                         NDR_PULL_ALLOC(ndr, r->level1);
18215                                 } else {
18216                                         r->level1 = NULL;
18217                                 }
18218                         break; }
18219
18220                         case 2: {
18221                                 uint32_t _ptr_level2;
18222                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18223                                 if (_ptr_level2) {
18224                                         NDR_PULL_ALLOC(ndr, r->level2);
18225                                 } else {
18226                                         r->level2 = NULL;
18227                                 }
18228                         break; }
18229
18230                         case 3: {
18231                                 uint32_t _ptr_level3;
18232                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18233                                 if (_ptr_level3) {
18234                                         NDR_PULL_ALLOC(ndr, r->level3);
18235                                 } else {
18236                                         r->level3 = NULL;
18237                                 }
18238                         break; }
18239
18240                         default:
18241                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18242                 }
18243         }
18244         if (ndr_flags & NDR_BUFFERS) {
18245                 switch (level) {
18246                         case 1:
18247                                 if (r->level1) {
18248                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18249                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18250                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18251                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18252                                 }
18253                         break;
18254
18255                         case 2:
18256                                 if (r->level2) {
18257                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18258                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18259                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18260                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18261                                 }
18262                         break;
18263
18264                         case 3:
18265                                 if (r->level3) {
18266                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18267                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18268                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18269                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18270                                 }
18271                         break;
18272
18273                         default:
18274                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18275                 }
18276         }
18277         return NDR_ERR_SUCCESS;
18278 }
18279
18280 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18281 {
18282         int level;
18283         level = ndr_print_get_switch_value(ndr, r);
18284         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18285         switch (level) {
18286                 case 1:
18287                         ndr_print_ptr(ndr, "level1", r->level1);
18288                         ndr->depth++;
18289                         if (r->level1) {
18290                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18291                         }
18292                         ndr->depth--;
18293                 break;
18294
18295                 case 2:
18296                         ndr_print_ptr(ndr, "level2", r->level2);
18297                         ndr->depth++;
18298                         if (r->level2) {
18299                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18300                         }
18301                         ndr->depth--;
18302                 break;
18303
18304                 case 3:
18305                         ndr_print_ptr(ndr, "level3", r->level3);
18306                         ndr->depth++;
18307                         if (r->level3) {
18308                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18309                         }
18310                         ndr->depth--;
18311                 break;
18312
18313                 default:
18314                         ndr_print_bad_level(ndr, name, level);
18315         }
18316 }
18317
18318 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18319 {
18320         if (ndr_flags & NDR_SCALARS) {
18321                 NDR_CHECK(ndr_push_align(ndr, 4));
18322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18323                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18324                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18325         }
18326         if (ndr_flags & NDR_BUFFERS) {
18327                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18328         }
18329         return NDR_ERR_SUCCESS;
18330 }
18331
18332 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18333 {
18334         if (ndr_flags & NDR_SCALARS) {
18335                 NDR_CHECK(ndr_pull_align(ndr, 4));
18336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18337                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18338                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18339         }
18340         if (ndr_flags & NDR_BUFFERS) {
18341                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18342         }
18343         return NDR_ERR_SUCCESS;
18344 }
18345
18346 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18347 {
18348         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18349         ndr->depth++;
18350         ndr_print_uint32(ndr, "level", r->level);
18351         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18352         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18353         ndr->depth--;
18354 }
18355
18356 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18357 {
18358         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18359         return NDR_ERR_SUCCESS;
18360 }
18361
18362 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18363 {
18364         uint32_t v;
18365         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18366         *r = v;
18367         return NDR_ERR_SUCCESS;
18368 }
18369
18370 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18371 {
18372         ndr_print_uint32(ndr, name, r);
18373         ndr->depth++;
18374         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18375         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18376         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18377         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18378         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18379         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18380         ndr->depth--;
18381 }
18382
18383 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
18384 {
18385         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18386         if (ndr_flags & NDR_SCALARS) {
18387                 NDR_CHECK(ndr_push_align(ndr, 4));
18388                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18389                 {
18390                         uint32_t _flags_save_string = ndr->flags;
18391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18392                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
18393                         ndr->flags = _flags_save_string;
18394                 }
18395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
18396                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
18397                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
18398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
18399         }
18400         if (ndr_flags & NDR_BUFFERS) {
18401                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18402                 {
18403                         uint32_t _flags_save_string = ndr->flags;
18404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18405                         if (r->value_name) {
18406                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
18407                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
18408                         }
18409                         ndr->flags = _flags_save_string;
18410                 }
18411                 if (r->data) {
18412                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
18413                         {
18414                                 struct ndr_push *_ndr_data;
18415                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18416                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
18417                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18418                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18419                         }
18420                 }
18421         }
18422         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18423         return NDR_ERR_SUCCESS;
18424 }
18425
18426 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
18427 {
18428         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18429         uint32_t _ptr_value_name;
18430         TALLOC_CTX *_mem_save_value_name_0;
18431         uint32_t _ptr_data;
18432         TALLOC_CTX *_mem_save_data_0;
18433         if (ndr_flags & NDR_SCALARS) {
18434                 NDR_CHECK(ndr_pull_align(ndr, 4));
18435                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18436                 {
18437                         uint32_t _flags_save_string = ndr->flags;
18438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18439                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
18440                         if (_ptr_value_name) {
18441                                 NDR_PULL_ALLOC(ndr, r->value_name);
18442                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
18443                         } else {
18444                                 r->value_name = NULL;
18445                         }
18446                         ndr->flags = _flags_save_string;
18447                 }
18448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
18449                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
18450                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
18451                 if (_ptr_data) {
18452                         NDR_PULL_ALLOC(ndr, r->data);
18453                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
18454                 } else {
18455                         r->data = NULL;
18456                 }
18457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
18458         }
18459         if (ndr_flags & NDR_BUFFERS) {
18460                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18461                 {
18462                         uint32_t _flags_save_string = ndr->flags;
18463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18464                         if (r->value_name) {
18465                                 uint32_t _relative_save_offset;
18466                                 _relative_save_offset = ndr->offset;
18467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
18468                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18469                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
18470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
18471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
18472                                 ndr->offset = _relative_save_offset;
18473                         }
18474                         ndr->flags = _flags_save_string;
18475                 }
18476                 if (r->data) {
18477                         uint32_t _relative_save_offset;
18478                         _relative_save_offset = ndr->offset;
18479                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
18480                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
18481                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
18482                         {
18483                                 struct ndr_pull *_ndr_data;
18484                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18485                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
18486                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18487                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18488                         }
18489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
18490                         ndr->offset = _relative_save_offset;
18491                 }
18492         }
18493         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18494         return NDR_ERR_SUCCESS;
18495 }
18496
18497 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
18498 {
18499         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
18500         ndr->depth++;
18501         ndr_print_ptr(ndr, "value_name", r->value_name);
18502         ndr->depth++;
18503         if (r->value_name) {
18504                 ndr_print_string(ndr, "value_name", r->value_name);
18505         }
18506         ndr->depth--;
18507         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
18508         ndr_print_winreg_Type(ndr, "type", r->type);
18509         ndr_print_ptr(ndr, "data", r->data);
18510         ndr->depth++;
18511         if (r->data) {
18512                 ndr_print_set_switch_value(ndr, r->data, r->type);
18513                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
18514         }
18515         ndr->depth--;
18516         ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags):r->data_length);
18517         ndr->depth--;
18518 }
18519
18520 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
18521 {
18522         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
18523 }
18524
18525 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
18526 {
18527         if (ndr_flags & NDR_SCALARS) {
18528                 int level = ndr_push_get_switch_value(ndr, r);
18529                 switch (level) {
18530                         case 0: {
18531                         break; }
18532
18533                         case 1: {
18534                         break; }
18535
18536                         default: {
18537                                 {
18538                                         uint32_t _flags_save_string_array = ndr->flags;
18539                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18540                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
18541                                         ndr->flags = _flags_save_string_array;
18542                                 }
18543                         break; }
18544
18545                 }
18546         }
18547         if (ndr_flags & NDR_BUFFERS) {
18548                 int level = ndr_push_get_switch_value(ndr, r);
18549                 switch (level) {
18550                         case 0:
18551                         break;
18552
18553                         case 1:
18554                         break;
18555
18556                         default:
18557                         break;
18558
18559                 }
18560         }
18561         return NDR_ERR_SUCCESS;
18562 }
18563
18564 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
18565 {
18566         int level;
18567         level = ndr_pull_get_switch_value(ndr, r);
18568         if (ndr_flags & NDR_SCALARS) {
18569                 switch (level) {
18570                         case 0: {
18571                         break; }
18572
18573                         case 1: {
18574                         break; }
18575
18576                         default: {
18577                                 {
18578                                         uint32_t _flags_save_string_array = ndr->flags;
18579                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18580                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
18581                                         ndr->flags = _flags_save_string_array;
18582                                 }
18583                         break; }
18584
18585                 }
18586         }
18587         if (ndr_flags & NDR_BUFFERS) {
18588                 switch (level) {
18589                         case 0:
18590                         break;
18591
18592                         case 1:
18593                         break;
18594
18595                         default:
18596                         break;
18597
18598                 }
18599         }
18600         return NDR_ERR_SUCCESS;
18601 }
18602
18603 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
18604 {
18605         int level;
18606         level = ndr_print_get_switch_value(ndr, r);
18607         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
18608         switch (level) {
18609                 case 0:
18610                 break;
18611
18612                 case 1:
18613                 break;
18614
18615                 default:
18616                         ndr_print_string_array(ndr, "string_array", r->string_array);
18617                 break;
18618
18619         }
18620 }
18621
18622 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18623 {
18624         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18625         return NDR_ERR_SUCCESS;
18626 }
18627
18628 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18629 {
18630         uint32_t v;
18631         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18632         *r = v;
18633         return NDR_ERR_SUCCESS;
18634 }
18635
18636 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18637 {
18638         ndr_print_uint32(ndr, name, r);
18639         ndr->depth++;
18640         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18641         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18642         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18643         ndr->depth--;
18644 }
18645
18646 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18647 {
18648         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18649         return NDR_ERR_SUCCESS;
18650 }
18651
18652 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18653 {
18654         uint32_t v;
18655         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18656         *r = v;
18657         return NDR_ERR_SUCCESS;
18658 }
18659
18660 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18661 {
18662         const char *val = NULL;
18663
18664         switch (r) {
18665                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18666                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18667         }
18668         ndr_print_enum(ndr, name, "ENUM", val, r);
18669 }
18670
18671 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18672 {
18673         if (ndr_flags & NDR_SCALARS) {
18674                 NDR_CHECK(ndr_push_align(ndr, 4));
18675                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18676                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18677                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18678                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18679                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18680                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18681                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18683                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18684                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18685                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18686                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18690         }
18691         if (ndr_flags & NDR_BUFFERS) {
18692         }
18693         return NDR_ERR_SUCCESS;
18694 }
18695
18696 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18697 {
18698         if (ndr_flags & NDR_SCALARS) {
18699                 NDR_CHECK(ndr_pull_align(ndr, 4));
18700                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18701                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18702                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18705                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18706                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18708                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18709                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18710                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18711                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18714                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18715         }
18716         if (ndr_flags & NDR_BUFFERS) {
18717         }
18718         return NDR_ERR_SUCCESS;
18719 }
18720
18721 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18722 {
18723         ndr_print_struct(ndr, name, "spoolss_PortData1");
18724         ndr->depth++;
18725         ndr_print_string(ndr, "portname", r->portname);
18726         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18727         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18728         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18729         ndr_print_uint32(ndr, "reserved", r->reserved);
18730         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18731         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18732         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18733         ndr_print_string(ndr, "queue", r->queue);
18734         ndr_print_string(ndr, "ip_address", r->ip_address);
18735         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18736         ndr_print_string(ndr, "device_type", r->device_type);
18737         ndr_print_uint32(ndr, "port_number", r->port_number);
18738         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18739         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18740         ndr->depth--;
18741 }
18742
18743 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18744 {
18745         if (ndr_flags & NDR_SCALARS) {
18746                 NDR_CHECK(ndr_push_align(ndr, 4));
18747                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18749                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18752                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18753                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18755                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18756                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18761         }
18762         if (ndr_flags & NDR_BUFFERS) {
18763         }
18764         return NDR_ERR_SUCCESS;
18765 }
18766
18767 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18768 {
18769         if (ndr_flags & NDR_SCALARS) {
18770                 NDR_CHECK(ndr_pull_align(ndr, 4));
18771                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18772                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18773                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18774                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18775                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18776                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18777                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18778                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18779                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18780                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18782                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18785         }
18786         if (ndr_flags & NDR_BUFFERS) {
18787         }
18788         return NDR_ERR_SUCCESS;
18789 }
18790
18791 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18792 {
18793         ndr_print_struct(ndr, name, "spoolss_PortData2");
18794         ndr->depth++;
18795         ndr_print_string(ndr, "portname", r->portname);
18796         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18797         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18798         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18799         ndr_print_uint32(ndr, "reserved", r->reserved);
18800         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18801         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18802         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18803         ndr_print_string(ndr, "queue", r->queue);
18804         ndr_print_string(ndr, "device_type", r->device_type);
18805         ndr_print_uint32(ndr, "port_number", r->port_number);
18806         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18807         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18808         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18809         ndr->depth--;
18810 }
18811
18812 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18813 {
18814         if (ndr_flags & NDR_SCALARS) {
18815                 NDR_CHECK(ndr_push_align(ndr, 4));
18816                 {
18817                         uint32_t _flags_save_string = ndr->flags;
18818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18819                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18820                         ndr->flags = _flags_save_string;
18821                 }
18822         }
18823         if (ndr_flags & NDR_BUFFERS) {
18824         }
18825         return NDR_ERR_SUCCESS;
18826 }
18827
18828 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18829 {
18830         if (ndr_flags & NDR_SCALARS) {
18831                 NDR_CHECK(ndr_pull_align(ndr, 4));
18832                 {
18833                         uint32_t _flags_save_string = ndr->flags;
18834                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18835                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18836                         ndr->flags = _flags_save_string;
18837                 }
18838         }
18839         if (ndr_flags & NDR_BUFFERS) {
18840         }
18841         return NDR_ERR_SUCCESS;
18842 }
18843
18844 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18845 {
18846         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18847         ndr->depth++;
18848         ndr_print_string(ndr, "dll_name", r->dll_name);
18849         ndr->depth--;
18850 }
18851
18852 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18853 {
18854         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18855         return NDR_ERR_SUCCESS;
18856 }
18857
18858 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18859 {
18860         uint32_t v;
18861         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18862         *r = v;
18863         return NDR_ERR_SUCCESS;
18864 }
18865
18866 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18867 {
18868         ndr_print_uint32(ndr, name, r);
18869         ndr->depth++;
18870         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18871         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18872         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18873         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18874         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18875         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18876         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18877         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18878         ndr->depth--;
18879 }
18880
18881 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18882 {
18883         if (flags & NDR_IN) {
18884                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18886                 if (r->in.server) {
18887                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18888                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18890                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18891                 }
18892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18894                 if (r->in.buffer) {
18895                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18896                 }
18897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18898         }
18899         if (flags & NDR_OUT) {
18900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18901                 if (r->out.info) {
18902                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18903                 }
18904                 if (r->out.needed == NULL) {
18905                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18906                 }
18907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18908                 if (r->out.count == NULL) {
18909                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18910                 }
18911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18912                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18913         }
18914         return NDR_ERR_SUCCESS;
18915 }
18916
18917 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18918 {
18919         uint32_t _ptr_server;
18920         uint32_t _ptr_buffer;
18921         uint32_t _ptr_info;
18922         TALLOC_CTX *_mem_save_server_0;
18923         TALLOC_CTX *_mem_save_buffer_0;
18924         TALLOC_CTX *_mem_save_info_0;
18925         TALLOC_CTX *_mem_save_needed_0;
18926         TALLOC_CTX *_mem_save_count_0;
18927         if (flags & NDR_IN) {
18928                 ZERO_STRUCT(r->out);
18929
18930                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18931                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18932                 if (_ptr_server) {
18933                         NDR_PULL_ALLOC(ndr, r->in.server);
18934                 } else {
18935                         r->in.server = NULL;
18936                 }
18937                 if (r->in.server) {
18938                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18939                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18942                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18943                                 return 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));
18944                         }
18945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18948                 }
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                 NDR_PULL_ALLOC(ndr, r->out.count);
18966                 ZERO_STRUCTP(r->out.count);
18967         }
18968         if (flags & NDR_OUT) {
18969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18970                 if (_ptr_info) {
18971                         NDR_PULL_ALLOC(ndr, r->out.info);
18972                 } else {
18973                         r->out.info = NULL;
18974                 }
18975                 if (r->out.info) {
18976                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18977                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18978                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18979                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18980                 }
18981                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18982                         NDR_PULL_ALLOC(ndr, r->out.needed);
18983                 }
18984                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18985                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18987                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18988                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18989                         NDR_PULL_ALLOC(ndr, r->out.count);
18990                 }
18991                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18992                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18993                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18995                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18996         }
18997         return NDR_ERR_SUCCESS;
18998 }
18999
19000 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
19001 {
19002         uint32_t cntr_info_0;
19003         if (flags & NDR_IN) {
19004                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19006         }
19007         if (flags & NDR_OUT) {
19008                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19009                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19010                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19011                 }
19012                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19013                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19014                 }
19015         }
19016         return NDR_ERR_SUCCESS;
19017 }
19018
19019 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
19020 {
19021         uint32_t cntr_info_0;
19022         TALLOC_CTX *_mem_save_info_0;
19023         if (flags & NDR_IN) {
19024                 ZERO_STRUCT(r->out);
19025
19026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19027                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19028         }
19029         if (flags & NDR_OUT) {
19030                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19031                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19032                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19033                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19034                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19035                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19036                 }
19037                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19038                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19039                 }
19040                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19041         }
19042         return NDR_ERR_SUCCESS;
19043 }
19044
19045 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
19046 {
19047         uint32_t cntr_info_2;
19048         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
19049         ndr->depth++;
19050         if (flags & NDR_SET_VALUES) {
19051                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19052         }
19053         if (flags & NDR_IN) {
19054                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
19055                 ndr->depth++;
19056                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
19057                 ndr_print_ptr(ndr, "server", r->in.server);
19058                 ndr->depth++;
19059                 if (r->in.server) {
19060                         ndr_print_string(ndr, "server", r->in.server);
19061                 }
19062                 ndr->depth--;
19063                 ndr_print_uint32(ndr, "level", r->in.level);
19064                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19065                 ndr->depth++;
19066                 if (r->in.buffer) {
19067                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19068                 }
19069                 ndr->depth--;
19070                 ndr_print_uint32(ndr, "offered", r->in.offered);
19071                 ndr->depth--;
19072         }
19073         if (flags & NDR_OUT) {
19074                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
19075                 ndr->depth++;
19076                 ndr_print_ptr(ndr, "count", r->out.count);
19077                 ndr->depth++;
19078                 ndr_print_uint32(ndr, "count", *r->out.count);
19079                 ndr->depth--;
19080                 ndr_print_ptr(ndr, "info", r->out.info);
19081                 ndr->depth++;
19082                 ndr_print_ptr(ndr, "info", *r->out.info);
19083                 ndr->depth++;
19084                 if (*r->out.info) {
19085                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19086                         ndr->depth++;
19087                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19088                                 char *idx_2=NULL;
19089                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19090                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19091                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19092                                         free(idx_2);
19093                                 }
19094                         }
19095                         ndr->depth--;
19096                 }
19097                 ndr->depth--;
19098                 ndr->depth--;
19099                 ndr_print_ptr(ndr, "needed", r->out.needed);
19100                 ndr->depth++;
19101                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19102                 ndr->depth--;
19103                 ndr_print_WERROR(ndr, "result", r->out.result);
19104                 ndr->depth--;
19105         }
19106         ndr->depth--;
19107 }
19108
19109 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
19110 {
19111         if (flags & NDR_IN) {
19112                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
19113                 if (r->in.printername) {
19114                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19117                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19118                 }
19119                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
19120                 if (r->in.datatype) {
19121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19125                 }
19126                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19127                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
19128         }
19129         if (flags & NDR_OUT) {
19130                 if (r->out.handle == NULL) {
19131                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19132                 }
19133                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19134                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19135         }
19136         return NDR_ERR_SUCCESS;
19137 }
19138
19139 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
19140 {
19141         uint32_t _ptr_printername;
19142         uint32_t _ptr_datatype;
19143         TALLOC_CTX *_mem_save_printername_0;
19144         TALLOC_CTX *_mem_save_datatype_0;
19145         TALLOC_CTX *_mem_save_handle_0;
19146         if (flags & NDR_IN) {
19147                 ZERO_STRUCT(r->out);
19148
19149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
19150                 if (_ptr_printername) {
19151                         NDR_PULL_ALLOC(ndr, r->in.printername);
19152                 } else {
19153                         r->in.printername = NULL;
19154                 }
19155                 if (r->in.printername) {
19156                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19157                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
19158                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
19159                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
19160                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
19161                                 return 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));
19162                         }
19163                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
19164                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
19165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
19166                 }
19167                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
19168                 if (_ptr_datatype) {
19169                         NDR_PULL_ALLOC(ndr, r->in.datatype);
19170                 } else {
19171                         r->in.datatype = NULL;
19172                 }
19173                 if (r->in.datatype) {
19174                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
19175                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
19176                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
19177                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
19178                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
19179                                 return 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));
19180                         }
19181                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
19182                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
19183                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
19184                 }
19185                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19186                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
19187                 NDR_PULL_ALLOC(ndr, r->out.handle);
19188                 ZERO_STRUCTP(r->out.handle);
19189         }
19190         if (flags & NDR_OUT) {
19191                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19192                         NDR_PULL_ALLOC(ndr, r->out.handle);
19193                 }
19194                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19195                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19196                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19197                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19198                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19199         }
19200         return NDR_ERR_SUCCESS;
19201 }
19202
19203 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
19204 {
19205         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
19206         ndr->depth++;
19207         if (flags & NDR_SET_VALUES) {
19208                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19209         }
19210         if (flags & NDR_IN) {
19211                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
19212                 ndr->depth++;
19213                 ndr_print_ptr(ndr, "printername", r->in.printername);
19214                 ndr->depth++;
19215                 if (r->in.printername) {
19216                         ndr_print_string(ndr, "printername", r->in.printername);
19217                 }
19218                 ndr->depth--;
19219                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
19220                 ndr->depth++;
19221                 if (r->in.datatype) {
19222                         ndr_print_string(ndr, "datatype", r->in.datatype);
19223                 }
19224                 ndr->depth--;
19225                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
19226                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
19227                 ndr->depth--;
19228         }
19229         if (flags & NDR_OUT) {
19230                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
19231                 ndr->depth++;
19232                 ndr_print_ptr(ndr, "handle", r->out.handle);
19233                 ndr->depth++;
19234                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19235                 ndr->depth--;
19236                 ndr_print_WERROR(ndr, "result", r->out.result);
19237                 ndr->depth--;
19238         }
19239         ndr->depth--;
19240 }
19241
19242 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
19243 {
19244         if (flags & NDR_IN) {
19245                 if (r->in.handle == NULL) {
19246                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19247                 }
19248                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19250                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19251                 if (r->in.ctr) {
19252                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19253                 }
19254                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19255         }
19256         if (flags & NDR_OUT) {
19257                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19258         }
19259         return NDR_ERR_SUCCESS;
19260 }
19261
19262 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19263 {
19264         uint32_t _ptr_ctr;
19265         TALLOC_CTX *_mem_save_handle_0;
19266         TALLOC_CTX *_mem_save_ctr_0;
19267         if (flags & NDR_IN) {
19268                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19269                         NDR_PULL_ALLOC(ndr, r->in.handle);
19270                 }
19271                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19272                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19273                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19275                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19276                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19277                 if (_ptr_ctr) {
19278                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19279                 } else {
19280                         r->in.ctr = NULL;
19281                 }
19282                 if (r->in.ctr) {
19283                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19284                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
19285                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
19287                 }
19288                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
19289         }
19290         if (flags & NDR_OUT) {
19291                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19292         }
19293         return NDR_ERR_SUCCESS;
19294 }
19295
19296 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
19297 {
19298         ndr_print_struct(ndr, name, "spoolss_SetJob");
19299         ndr->depth++;
19300         if (flags & NDR_SET_VALUES) {
19301                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19302         }
19303         if (flags & NDR_IN) {
19304                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
19305                 ndr->depth++;
19306                 ndr_print_ptr(ndr, "handle", r->in.handle);
19307                 ndr->depth++;
19308                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19309                 ndr->depth--;
19310                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19311                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
19312                 ndr->depth++;
19313                 if (r->in.ctr) {
19314                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
19315                 }
19316                 ndr->depth--;
19317                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
19318                 ndr->depth--;
19319         }
19320         if (flags & NDR_OUT) {
19321                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
19322                 ndr->depth++;
19323                 ndr_print_WERROR(ndr, "result", r->out.result);
19324                 ndr->depth--;
19325         }
19326         ndr->depth--;
19327 }
19328
19329 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
19330 {
19331         if (flags & NDR_IN) {
19332                 if (r->in.handle == NULL) {
19333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19334                 }
19335                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19336                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19338                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19339                 if (r->in.buffer) {
19340                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19341                 }
19342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19343         }
19344         if (flags & NDR_OUT) {
19345                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19346                 if (r->out.info) {
19347                         {
19348                                 struct ndr_push *_ndr_info;
19349                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19350                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19351                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19352                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19353                         }
19354                 }
19355                 if (r->out.needed == NULL) {
19356                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19357                 }
19358                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19359                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19360         }
19361         return NDR_ERR_SUCCESS;
19362 }
19363
19364 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
19365 {
19366         uint32_t _ptr_buffer;
19367         uint32_t _ptr_info;
19368         TALLOC_CTX *_mem_save_handle_0;
19369         TALLOC_CTX *_mem_save_buffer_0;
19370         TALLOC_CTX *_mem_save_info_0;
19371         TALLOC_CTX *_mem_save_needed_0;
19372         if (flags & NDR_IN) {
19373                 ZERO_STRUCT(r->out);
19374
19375                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19376                         NDR_PULL_ALLOC(ndr, r->in.handle);
19377                 }
19378                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19379                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19380                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19381                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19382                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19383                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19384                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19385                 if (_ptr_buffer) {
19386                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19387                 } else {
19388                         r->in.buffer = NULL;
19389                 }
19390                 if (r->in.buffer) {
19391                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19392                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19393                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19394                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19395                 }
19396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19397                 NDR_PULL_ALLOC(ndr, r->out.needed);
19398                 ZERO_STRUCTP(r->out.needed);
19399         }
19400         if (flags & NDR_OUT) {
19401                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19402                 if (_ptr_info) {
19403                         NDR_PULL_ALLOC(ndr, r->out.info);
19404                 } else {
19405                         r->out.info = NULL;
19406                 }
19407                 if (r->out.info) {
19408                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19409                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19410                         {
19411                                 struct ndr_pull *_ndr_info;
19412                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19413                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19414                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19415                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19416                         }
19417                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19418                 }
19419                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19420                         NDR_PULL_ALLOC(ndr, r->out.needed);
19421                 }
19422                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19423                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19425                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19426                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19427         }
19428         return NDR_ERR_SUCCESS;
19429 }
19430
19431 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19432 {
19433         ndr_print_struct(ndr, name, "spoolss_GetJob");
19434         ndr->depth++;
19435         if (flags & NDR_SET_VALUES) {
19436                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19437         }
19438         if (flags & NDR_IN) {
19439                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19440                 ndr->depth++;
19441                 ndr_print_ptr(ndr, "handle", r->in.handle);
19442                 ndr->depth++;
19443                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19444                 ndr->depth--;
19445                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19446                 ndr_print_uint32(ndr, "level", r->in.level);
19447                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19448                 ndr->depth++;
19449                 if (r->in.buffer) {
19450                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19451                 }
19452                 ndr->depth--;
19453                 ndr_print_uint32(ndr, "offered", r->in.offered);
19454                 ndr->depth--;
19455         }
19456         if (flags & NDR_OUT) {
19457                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19458                 ndr->depth++;
19459                 ndr_print_ptr(ndr, "info", r->out.info);
19460                 ndr->depth++;
19461                 if (r->out.info) {
19462                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19463                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19464                 }
19465                 ndr->depth--;
19466                 ndr_print_ptr(ndr, "needed", r->out.needed);
19467                 ndr->depth++;
19468                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19469                 ndr->depth--;
19470                 ndr_print_WERROR(ndr, "result", r->out.result);
19471                 ndr->depth--;
19472         }
19473         ndr->depth--;
19474 }
19475
19476 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19477 {
19478         if (flags & NDR_IN) {
19479                 if (r->in.handle == NULL) {
19480                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19481                 }
19482                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19483                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19486                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19487                 if (r->in.buffer) {
19488                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19489                 }
19490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19491         }
19492         if (flags & NDR_OUT) {
19493                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19494                 if (r->out.info) {
19495                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19496                 }
19497                 if (r->out.needed == NULL) {
19498                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19499                 }
19500                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19501                 if (r->out.count == NULL) {
19502                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19503                 }
19504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19505                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19506         }
19507         return NDR_ERR_SUCCESS;
19508 }
19509
19510 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19511 {
19512         uint32_t _ptr_buffer;
19513         uint32_t _ptr_info;
19514         TALLOC_CTX *_mem_save_handle_0;
19515         TALLOC_CTX *_mem_save_buffer_0;
19516         TALLOC_CTX *_mem_save_info_0;
19517         TALLOC_CTX *_mem_save_needed_0;
19518         TALLOC_CTX *_mem_save_count_0;
19519         if (flags & NDR_IN) {
19520                 ZERO_STRUCT(r->out);
19521
19522                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19523                         NDR_PULL_ALLOC(ndr, r->in.handle);
19524                 }
19525                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19526                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19527                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19528                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19533                 if (_ptr_buffer) {
19534                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19535                 } else {
19536                         r->in.buffer = NULL;
19537                 }
19538                 if (r->in.buffer) {
19539                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19540                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19541                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19542                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19543                 }
19544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19545                 NDR_PULL_ALLOC(ndr, r->out.needed);
19546                 ZERO_STRUCTP(r->out.needed);
19547                 NDR_PULL_ALLOC(ndr, r->out.count);
19548                 ZERO_STRUCTP(r->out.count);
19549         }
19550         if (flags & NDR_OUT) {
19551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19552                 if (_ptr_info) {
19553                         NDR_PULL_ALLOC(ndr, r->out.info);
19554                 } else {
19555                         r->out.info = NULL;
19556                 }
19557                 if (r->out.info) {
19558                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19559                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19560                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19561                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19562                 }
19563                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19564                         NDR_PULL_ALLOC(ndr, r->out.needed);
19565                 }
19566                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19567                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19568                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19569                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19570                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19571                         NDR_PULL_ALLOC(ndr, r->out.count);
19572                 }
19573                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19574                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19576                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19577                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19578         }
19579         return NDR_ERR_SUCCESS;
19580 }
19581
19582 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19583 {
19584         uint32_t cntr_info_0;
19585         if (flags & NDR_IN) {
19586                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19587                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19588         }
19589         if (flags & NDR_OUT) {
19590                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19591                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19592                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19593                 }
19594                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19595                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19596                 }
19597         }
19598         return NDR_ERR_SUCCESS;
19599 }
19600
19601 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19602 {
19603         uint32_t cntr_info_0;
19604         TALLOC_CTX *_mem_save_info_0;
19605         if (flags & NDR_IN) {
19606                 ZERO_STRUCT(r->out);
19607
19608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19609                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19610         }
19611         if (flags & NDR_OUT) {
19612                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19613                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19614                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19615                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19616                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19617                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19618                 }
19619                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19620                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19621                 }
19622                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19623         }
19624         return NDR_ERR_SUCCESS;
19625 }
19626
19627 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19628 {
19629         uint32_t cntr_info_2;
19630         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19631         ndr->depth++;
19632         if (flags & NDR_SET_VALUES) {
19633                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19634         }
19635         if (flags & NDR_IN) {
19636                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19637                 ndr->depth++;
19638                 ndr_print_ptr(ndr, "handle", r->in.handle);
19639                 ndr->depth++;
19640                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19641                 ndr->depth--;
19642                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19643                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19644                 ndr_print_uint32(ndr, "level", r->in.level);
19645                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19646                 ndr->depth++;
19647                 if (r->in.buffer) {
19648                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19649                 }
19650                 ndr->depth--;
19651                 ndr_print_uint32(ndr, "offered", r->in.offered);
19652                 ndr->depth--;
19653         }
19654         if (flags & NDR_OUT) {
19655                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19656                 ndr->depth++;
19657                 ndr_print_ptr(ndr, "count", r->out.count);
19658                 ndr->depth++;
19659                 ndr_print_uint32(ndr, "count", *r->out.count);
19660                 ndr->depth--;
19661                 ndr_print_ptr(ndr, "info", r->out.info);
19662                 ndr->depth++;
19663                 ndr_print_ptr(ndr, "info", *r->out.info);
19664                 ndr->depth++;
19665                 if (*r->out.info) {
19666                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19667                         ndr->depth++;
19668                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19669                                 char *idx_2=NULL;
19670                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19671                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19672                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19673                                         free(idx_2);
19674                                 }
19675                         }
19676                         ndr->depth--;
19677                 }
19678                 ndr->depth--;
19679                 ndr->depth--;
19680                 ndr_print_ptr(ndr, "needed", r->out.needed);
19681                 ndr->depth++;
19682                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19683                 ndr->depth--;
19684                 ndr_print_WERROR(ndr, "result", r->out.result);
19685                 ndr->depth--;
19686         }
19687         ndr->depth--;
19688 }
19689
19690 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19691 {
19692         if (flags & NDR_IN) {
19693         }
19694         if (flags & NDR_OUT) {
19695                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19696         }
19697         return NDR_ERR_SUCCESS;
19698 }
19699
19700 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19701 {
19702         if (flags & NDR_IN) {
19703         }
19704         if (flags & NDR_OUT) {
19705                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19706         }
19707         return NDR_ERR_SUCCESS;
19708 }
19709
19710 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19711 {
19712         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19713         ndr->depth++;
19714         if (flags & NDR_SET_VALUES) {
19715                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19716         }
19717         if (flags & NDR_IN) {
19718                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19719                 ndr->depth++;
19720                 ndr->depth--;
19721         }
19722         if (flags & NDR_OUT) {
19723                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19724                 ndr->depth++;
19725                 ndr_print_WERROR(ndr, "result", r->out.result);
19726                 ndr->depth--;
19727         }
19728         ndr->depth--;
19729 }
19730
19731 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19732 {
19733         if (flags & NDR_IN) {
19734                 if (r->in.handle == NULL) {
19735                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19736                 }
19737                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19738         }
19739         if (flags & NDR_OUT) {
19740                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19741         }
19742         return NDR_ERR_SUCCESS;
19743 }
19744
19745 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19746 {
19747         TALLOC_CTX *_mem_save_handle_0;
19748         if (flags & NDR_IN) {
19749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19750                         NDR_PULL_ALLOC(ndr, r->in.handle);
19751                 }
19752                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19753                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19754                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19756         }
19757         if (flags & NDR_OUT) {
19758                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19759         }
19760         return NDR_ERR_SUCCESS;
19761 }
19762
19763 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19764 {
19765         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19766         ndr->depth++;
19767         if (flags & NDR_SET_VALUES) {
19768                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19769         }
19770         if (flags & NDR_IN) {
19771                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19772                 ndr->depth++;
19773                 ndr_print_ptr(ndr, "handle", r->in.handle);
19774                 ndr->depth++;
19775                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19776                 ndr->depth--;
19777                 ndr->depth--;
19778         }
19779         if (flags & NDR_OUT) {
19780                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19781                 ndr->depth++;
19782                 ndr_print_WERROR(ndr, "result", r->out.result);
19783                 ndr->depth--;
19784         }
19785         ndr->depth--;
19786 }
19787
19788 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19789 {
19790         if (flags & NDR_IN) {
19791                 if (r->in.handle == NULL) {
19792                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19793                 }
19794                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19795                 if (r->in.info_ctr == NULL) {
19796                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19797                 }
19798                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19799                 if (r->in.devmode_ctr == NULL) {
19800                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19801                 }
19802                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19803                 if (r->in.secdesc_ctr == NULL) {
19804                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19805                 }
19806                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19807                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19808         }
19809         if (flags & NDR_OUT) {
19810                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19811         }
19812         return NDR_ERR_SUCCESS;
19813 }
19814
19815 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19816 {
19817         TALLOC_CTX *_mem_save_handle_0;
19818         TALLOC_CTX *_mem_save_info_ctr_0;
19819         TALLOC_CTX *_mem_save_devmode_ctr_0;
19820         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19821         if (flags & NDR_IN) {
19822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19823                         NDR_PULL_ALLOC(ndr, r->in.handle);
19824                 }
19825                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19826                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19827                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19829                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19830                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19831                 }
19832                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19833                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19834                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19835                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19836                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19837                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19838                 }
19839                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19840                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19841                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19842                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19843                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19844                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19845                 }
19846                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19847                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19848                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19849                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19850                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19851         }
19852         if (flags & NDR_OUT) {
19853                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19854         }
19855         return NDR_ERR_SUCCESS;
19856 }
19857
19858 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19859 {
19860         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19861         ndr->depth++;
19862         if (flags & NDR_SET_VALUES) {
19863                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19864         }
19865         if (flags & NDR_IN) {
19866                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19867                 ndr->depth++;
19868                 ndr_print_ptr(ndr, "handle", r->in.handle);
19869                 ndr->depth++;
19870                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19871                 ndr->depth--;
19872                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19873                 ndr->depth++;
19874                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19875                 ndr->depth--;
19876                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19877                 ndr->depth++;
19878                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19879                 ndr->depth--;
19880                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19881                 ndr->depth++;
19882                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19883                 ndr->depth--;
19884                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19885                 ndr->depth--;
19886         }
19887         if (flags & NDR_OUT) {
19888                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19889                 ndr->depth++;
19890                 ndr_print_WERROR(ndr, "result", r->out.result);
19891                 ndr->depth--;
19892         }
19893         ndr->depth--;
19894 }
19895
19896 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19897 {
19898         if (flags & NDR_IN) {
19899                 if (r->in.handle == NULL) {
19900                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19901                 }
19902                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19903                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19905                 if (r->in.buffer) {
19906                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19907                 }
19908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19909         }
19910         if (flags & NDR_OUT) {
19911                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19912                 if (r->out.info) {
19913                         {
19914                                 struct ndr_push *_ndr_info;
19915                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19916                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19917                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19918                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19919                         }
19920                 }
19921                 if (r->out.needed == NULL) {
19922                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19923                 }
19924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19925                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19926         }
19927         return NDR_ERR_SUCCESS;
19928 }
19929
19930 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19931 {
19932         uint32_t _ptr_buffer;
19933         uint32_t _ptr_info;
19934         TALLOC_CTX *_mem_save_handle_0;
19935         TALLOC_CTX *_mem_save_buffer_0;
19936         TALLOC_CTX *_mem_save_info_0;
19937         TALLOC_CTX *_mem_save_needed_0;
19938         if (flags & NDR_IN) {
19939                 ZERO_STRUCT(r->out);
19940
19941                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19942                         NDR_PULL_ALLOC(ndr, r->in.handle);
19943                 }
19944                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19945                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19946                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19947                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19948                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19950                 if (_ptr_buffer) {
19951                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19952                 } else {
19953                         r->in.buffer = NULL;
19954                 }
19955                 if (r->in.buffer) {
19956                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19957                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19958                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19959                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19960                 }
19961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19962                 NDR_PULL_ALLOC(ndr, r->out.needed);
19963                 ZERO_STRUCTP(r->out.needed);
19964         }
19965         if (flags & NDR_OUT) {
19966                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19967                 if (_ptr_info) {
19968                         NDR_PULL_ALLOC(ndr, r->out.info);
19969                 } else {
19970                         r->out.info = NULL;
19971                 }
19972                 if (r->out.info) {
19973                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19974                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19975                         {
19976                                 struct ndr_pull *_ndr_info;
19977                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19978                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19979                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19980                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19981                         }
19982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19983                 }
19984                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19985                         NDR_PULL_ALLOC(ndr, r->out.needed);
19986                 }
19987                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19988                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19989                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19990                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19991                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19992         }
19993         return NDR_ERR_SUCCESS;
19994 }
19995
19996 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19997 {
19998         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19999         ndr->depth++;
20000         if (flags & NDR_SET_VALUES) {
20001                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20002         }
20003         if (flags & NDR_IN) {
20004                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
20005                 ndr->depth++;
20006                 ndr_print_ptr(ndr, "handle", r->in.handle);
20007                 ndr->depth++;
20008                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20009                 ndr->depth--;
20010                 ndr_print_uint32(ndr, "level", r->in.level);
20011                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20012                 ndr->depth++;
20013                 if (r->in.buffer) {
20014                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20015                 }
20016                 ndr->depth--;
20017                 ndr_print_uint32(ndr, "offered", r->in.offered);
20018                 ndr->depth--;
20019         }
20020         if (flags & NDR_OUT) {
20021                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
20022                 ndr->depth++;
20023                 ndr_print_ptr(ndr, "info", r->out.info);
20024                 ndr->depth++;
20025                 if (r->out.info) {
20026                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20027                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
20028                 }
20029                 ndr->depth--;
20030                 ndr_print_ptr(ndr, "needed", r->out.needed);
20031                 ndr->depth++;
20032                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20033                 ndr->depth--;
20034                 ndr_print_WERROR(ndr, "result", r->out.result);
20035                 ndr->depth--;
20036         }
20037         ndr->depth--;
20038 }
20039
20040 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
20041 {
20042         if (flags & NDR_IN) {
20043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20044                 if (r->in.servername) {
20045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20048                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20049                 }
20050                 if (r->in.info_ctr == NULL) {
20051                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20052                 }
20053                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20054         }
20055         if (flags & NDR_OUT) {
20056                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20057         }
20058         return NDR_ERR_SUCCESS;
20059 }
20060
20061 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
20062 {
20063         uint32_t _ptr_servername;
20064         TALLOC_CTX *_mem_save_servername_0;
20065         TALLOC_CTX *_mem_save_info_ctr_0;
20066         if (flags & NDR_IN) {
20067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20068                 if (_ptr_servername) {
20069                         NDR_PULL_ALLOC(ndr, r->in.servername);
20070                 } else {
20071                         r->in.servername = NULL;
20072                 }
20073                 if (r->in.servername) {
20074                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20075                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20076                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20077                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20078                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20079                                 return 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));
20080                         }
20081                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20082                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20083                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20084                 }
20085                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20086                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20087                 }
20088                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20089                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20090                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20091                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20092         }
20093         if (flags & NDR_OUT) {
20094                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20095         }
20096         return NDR_ERR_SUCCESS;
20097 }
20098
20099 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
20100 {
20101         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
20102         ndr->depth++;
20103         if (flags & NDR_SET_VALUES) {
20104                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20105         }
20106         if (flags & NDR_IN) {
20107                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
20108                 ndr->depth++;
20109                 ndr_print_ptr(ndr, "servername", r->in.servername);
20110                 ndr->depth++;
20111                 if (r->in.servername) {
20112                         ndr_print_string(ndr, "servername", r->in.servername);
20113                 }
20114                 ndr->depth--;
20115                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20116                 ndr->depth++;
20117                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20118                 ndr->depth--;
20119                 ndr->depth--;
20120         }
20121         if (flags & NDR_OUT) {
20122                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
20123                 ndr->depth++;
20124                 ndr_print_WERROR(ndr, "result", r->out.result);
20125                 ndr->depth--;
20126         }
20127         ndr->depth--;
20128 }
20129
20130 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
20131 {
20132         if (flags & NDR_IN) {
20133                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20134                 if (r->in.server) {
20135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20139                 }
20140                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20141                 if (r->in.environment) {
20142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20144                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20145                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20146                 }
20147                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20148                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20149                 if (r->in.buffer) {
20150                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20151                 }
20152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20153         }
20154         if (flags & NDR_OUT) {
20155                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20156                 if (r->out.info) {
20157                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20158                 }
20159                 if (r->out.needed == NULL) {
20160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20161                 }
20162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20163                 if (r->out.count == NULL) {
20164                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20165                 }
20166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20167                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20168         }
20169         return NDR_ERR_SUCCESS;
20170 }
20171
20172 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
20173 {
20174         uint32_t _ptr_server;
20175         uint32_t _ptr_environment;
20176         uint32_t _ptr_buffer;
20177         uint32_t _ptr_info;
20178         TALLOC_CTX *_mem_save_server_0;
20179         TALLOC_CTX *_mem_save_environment_0;
20180         TALLOC_CTX *_mem_save_buffer_0;
20181         TALLOC_CTX *_mem_save_info_0;
20182         TALLOC_CTX *_mem_save_needed_0;
20183         TALLOC_CTX *_mem_save_count_0;
20184         if (flags & NDR_IN) {
20185                 ZERO_STRUCT(r->out);
20186
20187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20188                 if (_ptr_server) {
20189                         NDR_PULL_ALLOC(ndr, r->in.server);
20190                 } else {
20191                         r->in.server = NULL;
20192                 }
20193                 if (r->in.server) {
20194                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20195                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20198                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20199                                 return 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));
20200                         }
20201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20204                 }
20205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20206                 if (_ptr_environment) {
20207                         NDR_PULL_ALLOC(ndr, r->in.environment);
20208                 } else {
20209                         r->in.environment = NULL;
20210                 }
20211                 if (r->in.environment) {
20212                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20213                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20214                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20215                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20216                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20217                                 return 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));
20218                         }
20219                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20220                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20221                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20222                 }
20223                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20224                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20225                 if (_ptr_buffer) {
20226                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20227                 } else {
20228                         r->in.buffer = NULL;
20229                 }
20230                 if (r->in.buffer) {
20231                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20232                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20233                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20234                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20235                 }
20236                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20237                 NDR_PULL_ALLOC(ndr, r->out.needed);
20238                 ZERO_STRUCTP(r->out.needed);
20239                 NDR_PULL_ALLOC(ndr, r->out.count);
20240                 ZERO_STRUCTP(r->out.count);
20241         }
20242         if (flags & NDR_OUT) {
20243                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20244                 if (_ptr_info) {
20245                         NDR_PULL_ALLOC(ndr, r->out.info);
20246                 } else {
20247                         r->out.info = NULL;
20248                 }
20249                 if (r->out.info) {
20250                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20251                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20252                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20253                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20254                 }
20255                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20256                         NDR_PULL_ALLOC(ndr, r->out.needed);
20257                 }
20258                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20259                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20261                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20262                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20263                         NDR_PULL_ALLOC(ndr, r->out.count);
20264                 }
20265                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20266                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20267                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20268                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20269                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20270         }
20271         return NDR_ERR_SUCCESS;
20272 }
20273
20274 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
20275 {
20276         uint32_t cntr_info_0;
20277         if (flags & NDR_IN) {
20278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20280         }
20281         if (flags & NDR_OUT) {
20282                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20283                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20284                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20285                 }
20286                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20287                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20288                 }
20289         }
20290         return NDR_ERR_SUCCESS;
20291 }
20292
20293 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
20294 {
20295         uint32_t cntr_info_0;
20296         TALLOC_CTX *_mem_save_info_0;
20297         if (flags & NDR_IN) {
20298                 ZERO_STRUCT(r->out);
20299
20300                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20302         }
20303         if (flags & NDR_OUT) {
20304                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20305                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20306                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20307                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20308                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20309                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20310                 }
20311                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20312                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20313                 }
20314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20315         }
20316         return NDR_ERR_SUCCESS;
20317 }
20318
20319 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
20320 {
20321         uint32_t cntr_info_2;
20322         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
20323         ndr->depth++;
20324         if (flags & NDR_SET_VALUES) {
20325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20326         }
20327         if (flags & NDR_IN) {
20328                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
20329                 ndr->depth++;
20330                 ndr_print_ptr(ndr, "server", r->in.server);
20331                 ndr->depth++;
20332                 if (r->in.server) {
20333                         ndr_print_string(ndr, "server", r->in.server);
20334                 }
20335                 ndr->depth--;
20336                 ndr_print_ptr(ndr, "environment", r->in.environment);
20337                 ndr->depth++;
20338                 if (r->in.environment) {
20339                         ndr_print_string(ndr, "environment", r->in.environment);
20340                 }
20341                 ndr->depth--;
20342                 ndr_print_uint32(ndr, "level", r->in.level);
20343                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20344                 ndr->depth++;
20345                 if (r->in.buffer) {
20346                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20347                 }
20348                 ndr->depth--;
20349                 ndr_print_uint32(ndr, "offered", r->in.offered);
20350                 ndr->depth--;
20351         }
20352         if (flags & NDR_OUT) {
20353                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
20354                 ndr->depth++;
20355                 ndr_print_ptr(ndr, "count", r->out.count);
20356                 ndr->depth++;
20357                 ndr_print_uint32(ndr, "count", *r->out.count);
20358                 ndr->depth--;
20359                 ndr_print_ptr(ndr, "info", r->out.info);
20360                 ndr->depth++;
20361                 ndr_print_ptr(ndr, "info", *r->out.info);
20362                 ndr->depth++;
20363                 if (*r->out.info) {
20364                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20365                         ndr->depth++;
20366                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20367                                 char *idx_2=NULL;
20368                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20369                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20370                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20371                                         free(idx_2);
20372                                 }
20373                         }
20374                         ndr->depth--;
20375                 }
20376                 ndr->depth--;
20377                 ndr->depth--;
20378                 ndr_print_ptr(ndr, "needed", r->out.needed);
20379                 ndr->depth++;
20380                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20381                 ndr->depth--;
20382                 ndr_print_WERROR(ndr, "result", r->out.result);
20383                 ndr->depth--;
20384         }
20385         ndr->depth--;
20386 }
20387
20388 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20389 {
20390         if (flags & NDR_IN) {
20391         }
20392         if (flags & NDR_OUT) {
20393                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20394         }
20395         return NDR_ERR_SUCCESS;
20396 }
20397
20398 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20399 {
20400         if (flags & NDR_IN) {
20401         }
20402         if (flags & NDR_OUT) {
20403                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20404         }
20405         return NDR_ERR_SUCCESS;
20406 }
20407
20408 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20409 {
20410         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
20411         ndr->depth++;
20412         if (flags & NDR_SET_VALUES) {
20413                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20414         }
20415         if (flags & NDR_IN) {
20416                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20417                 ndr->depth++;
20418                 ndr->depth--;
20419         }
20420         if (flags & NDR_OUT) {
20421                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20422                 ndr->depth++;
20423                 ndr_print_WERROR(ndr, "result", r->out.result);
20424                 ndr->depth--;
20425         }
20426         ndr->depth--;
20427 }
20428
20429 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20430 {
20431         if (flags & NDR_IN) {
20432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20433                 if (r->in.server) {
20434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20437                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20438                 }
20439                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20440                 if (r->in.environment) {
20441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20445                 }
20446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20447                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20448                 if (r->in.buffer) {
20449                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20450                 }
20451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20452         }
20453         if (flags & NDR_OUT) {
20454                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20455                 if (r->out.info) {
20456                         {
20457                                 struct ndr_push *_ndr_info;
20458                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20459                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20460                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20461                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20462                         }
20463                 }
20464                 if (r->out.needed == NULL) {
20465                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20466                 }
20467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20468                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20469         }
20470         return NDR_ERR_SUCCESS;
20471 }
20472
20473 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20474 {
20475         uint32_t _ptr_server;
20476         uint32_t _ptr_environment;
20477         uint32_t _ptr_buffer;
20478         uint32_t _ptr_info;
20479         TALLOC_CTX *_mem_save_server_0;
20480         TALLOC_CTX *_mem_save_environment_0;
20481         TALLOC_CTX *_mem_save_buffer_0;
20482         TALLOC_CTX *_mem_save_info_0;
20483         TALLOC_CTX *_mem_save_needed_0;
20484         if (flags & NDR_IN) {
20485                 ZERO_STRUCT(r->out);
20486
20487                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20488                 if (_ptr_server) {
20489                         NDR_PULL_ALLOC(ndr, r->in.server);
20490                 } else {
20491                         r->in.server = NULL;
20492                 }
20493                 if (r->in.server) {
20494                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20495                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20496                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20497                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20498                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20499                                 return 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));
20500                         }
20501                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20502                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20503                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20504                 }
20505                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20506                 if (_ptr_environment) {
20507                         NDR_PULL_ALLOC(ndr, r->in.environment);
20508                 } else {
20509                         r->in.environment = NULL;
20510                 }
20511                 if (r->in.environment) {
20512                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20513                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20514                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20515                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20516                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20517                                 return 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));
20518                         }
20519                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20520                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20521                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20522                 }
20523                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20524                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20525                 if (_ptr_buffer) {
20526                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20527                 } else {
20528                         r->in.buffer = NULL;
20529                 }
20530                 if (r->in.buffer) {
20531                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20532                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20533                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20535                 }
20536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20537                 NDR_PULL_ALLOC(ndr, r->out.needed);
20538                 ZERO_STRUCTP(r->out.needed);
20539         }
20540         if (flags & NDR_OUT) {
20541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20542                 if (_ptr_info) {
20543                         NDR_PULL_ALLOC(ndr, r->out.info);
20544                 } else {
20545                         r->out.info = NULL;
20546                 }
20547                 if (r->out.info) {
20548                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20549                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20550                         {
20551                                 struct ndr_pull *_ndr_info;
20552                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20553                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20554                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20555                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20556                         }
20557                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20558                 }
20559                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20560                         NDR_PULL_ALLOC(ndr, r->out.needed);
20561                 }
20562                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20563                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20565                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20566                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20567         }
20568         return NDR_ERR_SUCCESS;
20569 }
20570
20571 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20572 {
20573         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20574         ndr->depth++;
20575         if (flags & NDR_SET_VALUES) {
20576                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20577         }
20578         if (flags & NDR_IN) {
20579                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20580                 ndr->depth++;
20581                 ndr_print_ptr(ndr, "server", r->in.server);
20582                 ndr->depth++;
20583                 if (r->in.server) {
20584                         ndr_print_string(ndr, "server", r->in.server);
20585                 }
20586                 ndr->depth--;
20587                 ndr_print_ptr(ndr, "environment", r->in.environment);
20588                 ndr->depth++;
20589                 if (r->in.environment) {
20590                         ndr_print_string(ndr, "environment", r->in.environment);
20591                 }
20592                 ndr->depth--;
20593                 ndr_print_uint32(ndr, "level", r->in.level);
20594                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20595                 ndr->depth++;
20596                 if (r->in.buffer) {
20597                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20598                 }
20599                 ndr->depth--;
20600                 ndr_print_uint32(ndr, "offered", r->in.offered);
20601                 ndr->depth--;
20602         }
20603         if (flags & NDR_OUT) {
20604                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20605                 ndr->depth++;
20606                 ndr_print_ptr(ndr, "info", r->out.info);
20607                 ndr->depth++;
20608                 if (r->out.info) {
20609                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20610                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20611                 }
20612                 ndr->depth--;
20613                 ndr_print_ptr(ndr, "needed", r->out.needed);
20614                 ndr->depth++;
20615                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20616                 ndr->depth--;
20617                 ndr_print_WERROR(ndr, "result", r->out.result);
20618                 ndr->depth--;
20619         }
20620         ndr->depth--;
20621 }
20622
20623 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20624 {
20625         if (flags & NDR_IN) {
20626                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20627                 if (r->in.server) {
20628                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20631                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20632                 }
20633                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20636                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20637                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20640                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20641         }
20642         if (flags & NDR_OUT) {
20643                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20644         }
20645         return NDR_ERR_SUCCESS;
20646 }
20647
20648 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20649 {
20650         uint32_t _ptr_server;
20651         TALLOC_CTX *_mem_save_server_0;
20652         if (flags & NDR_IN) {
20653                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20654                 if (_ptr_server) {
20655                         NDR_PULL_ALLOC(ndr, r->in.server);
20656                 } else {
20657                         r->in.server = NULL;
20658                 }
20659                 if (r->in.server) {
20660                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20661                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20662                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20663                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20664                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20665                                 return 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));
20666                         }
20667                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20668                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20669                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20670                 }
20671                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20672                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20673                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20674                         return 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));
20675                 }
20676                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20677                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20678                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20679                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20680                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20681                         return 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));
20682                 }
20683                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20684                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20685         }
20686         if (flags & NDR_OUT) {
20687                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20688         }
20689         return NDR_ERR_SUCCESS;
20690 }
20691
20692 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20693 {
20694         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20695         ndr->depth++;
20696         if (flags & NDR_SET_VALUES) {
20697                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20698         }
20699         if (flags & NDR_IN) {
20700                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20701                 ndr->depth++;
20702                 ndr_print_ptr(ndr, "server", r->in.server);
20703                 ndr->depth++;
20704                 if (r->in.server) {
20705                         ndr_print_string(ndr, "server", r->in.server);
20706                 }
20707                 ndr->depth--;
20708                 ndr_print_string(ndr, "architecture", r->in.architecture);
20709                 ndr_print_string(ndr, "driver", r->in.driver);
20710                 ndr->depth--;
20711         }
20712         if (flags & NDR_OUT) {
20713                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20714                 ndr->depth++;
20715                 ndr_print_WERROR(ndr, "result", r->out.result);
20716                 ndr->depth--;
20717         }
20718         ndr->depth--;
20719 }
20720
20721 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20722 {
20723         if (flags & NDR_IN) {
20724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20725                 if (r->in.server) {
20726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20729                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20730                 }
20731                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20732                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20734                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20736                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20738                 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));
20739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20742                 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));
20743         }
20744         if (flags & NDR_OUT) {
20745                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20746         }
20747         return NDR_ERR_SUCCESS;
20748 }
20749
20750 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20751 {
20752         uint32_t _ptr_server;
20753         TALLOC_CTX *_mem_save_server_0;
20754         if (flags & NDR_IN) {
20755                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20756                 if (_ptr_server) {
20757                         NDR_PULL_ALLOC(ndr, r->in.server);
20758                 } else {
20759                         r->in.server = NULL;
20760                 }
20761                 if (r->in.server) {
20762                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20763                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20764                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20765                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20766                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20767                                 return 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));
20768                         }
20769                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20770                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20771                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20772                 }
20773                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20774                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20775                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20776                         return 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));
20777                 }
20778                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20779                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20780                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20781                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20782                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20783                         return 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));
20784                 }
20785                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20786                 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));
20787                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20788                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20789                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20790                         return 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));
20791                 }
20792                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20793                 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));
20794         }
20795         if (flags & NDR_OUT) {
20796                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20797         }
20798         return NDR_ERR_SUCCESS;
20799 }
20800
20801 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20802 {
20803         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20804         ndr->depth++;
20805         if (flags & NDR_SET_VALUES) {
20806                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20807         }
20808         if (flags & NDR_IN) {
20809                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20810                 ndr->depth++;
20811                 ndr_print_ptr(ndr, "server", r->in.server);
20812                 ndr->depth++;
20813                 if (r->in.server) {
20814                         ndr_print_string(ndr, "server", r->in.server);
20815                 }
20816                 ndr->depth--;
20817                 ndr_print_string(ndr, "architecture", r->in.architecture);
20818                 ndr_print_string(ndr, "path_name", r->in.path_name);
20819                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20820                 ndr->depth--;
20821         }
20822         if (flags & NDR_OUT) {
20823                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20824                 ndr->depth++;
20825                 ndr_print_WERROR(ndr, "result", r->out.result);
20826                 ndr->depth--;
20827         }
20828         ndr->depth--;
20829 }
20830
20831 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20832 {
20833         if (flags & NDR_IN) {
20834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20835                 if (r->in.servername) {
20836                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20837                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20838                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20839                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20840                 }
20841                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20842                 if (r->in.environment) {
20843                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20844                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20846                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20847                 }
20848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20849                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20850                 if (r->in.buffer) {
20851                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20852                 }
20853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20854         }
20855         if (flags & NDR_OUT) {
20856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20857                 if (r->out.info) {
20858                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20859                 }
20860                 if (r->out.needed == NULL) {
20861                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20862                 }
20863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20864                 if (r->out.count == NULL) {
20865                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20866                 }
20867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20868                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20869         }
20870         return NDR_ERR_SUCCESS;
20871 }
20872
20873 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20874 {
20875         uint32_t _ptr_servername;
20876         uint32_t _ptr_environment;
20877         uint32_t _ptr_buffer;
20878         uint32_t _ptr_info;
20879         TALLOC_CTX *_mem_save_servername_0;
20880         TALLOC_CTX *_mem_save_environment_0;
20881         TALLOC_CTX *_mem_save_buffer_0;
20882         TALLOC_CTX *_mem_save_info_0;
20883         TALLOC_CTX *_mem_save_needed_0;
20884         TALLOC_CTX *_mem_save_count_0;
20885         if (flags & NDR_IN) {
20886                 ZERO_STRUCT(r->out);
20887
20888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20889                 if (_ptr_servername) {
20890                         NDR_PULL_ALLOC(ndr, r->in.servername);
20891                 } else {
20892                         r->in.servername = NULL;
20893                 }
20894                 if (r->in.servername) {
20895                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20896                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20898                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20899                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20900                                 return 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));
20901                         }
20902                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20903                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20905                 }
20906                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20907                 if (_ptr_environment) {
20908                         NDR_PULL_ALLOC(ndr, r->in.environment);
20909                 } else {
20910                         r->in.environment = NULL;
20911                 }
20912                 if (r->in.environment) {
20913                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20914                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20915                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20916                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20917                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20918                                 return 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));
20919                         }
20920                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20921                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20923                 }
20924                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20925                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20926                 if (_ptr_buffer) {
20927                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20928                 } else {
20929                         r->in.buffer = NULL;
20930                 }
20931                 if (r->in.buffer) {
20932                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20933                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20934                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20936                 }
20937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20938                 NDR_PULL_ALLOC(ndr, r->out.needed);
20939                 ZERO_STRUCTP(r->out.needed);
20940                 NDR_PULL_ALLOC(ndr, r->out.count);
20941                 ZERO_STRUCTP(r->out.count);
20942         }
20943         if (flags & NDR_OUT) {
20944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20945                 if (_ptr_info) {
20946                         NDR_PULL_ALLOC(ndr, r->out.info);
20947                 } else {
20948                         r->out.info = NULL;
20949                 }
20950                 if (r->out.info) {
20951                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20952                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20953                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20954                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20955                 }
20956                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20957                         NDR_PULL_ALLOC(ndr, r->out.needed);
20958                 }
20959                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20960                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20962                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20963                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20964                         NDR_PULL_ALLOC(ndr, r->out.count);
20965                 }
20966                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20967                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20968                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20969                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20970                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20971         }
20972         return NDR_ERR_SUCCESS;
20973 }
20974
20975 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20976 {
20977         uint32_t cntr_info_0;
20978         if (flags & NDR_IN) {
20979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20980                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20981         }
20982         if (flags & NDR_OUT) {
20983                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20984                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20985                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20986                 }
20987                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20988                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20989                 }
20990         }
20991         return NDR_ERR_SUCCESS;
20992 }
20993
20994 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20995 {
20996         uint32_t cntr_info_0;
20997         TALLOC_CTX *_mem_save_info_0;
20998         if (flags & NDR_IN) {
20999                 ZERO_STRUCT(r->out);
21000
21001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21003         }
21004         if (flags & NDR_OUT) {
21005                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21006                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21007                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21008                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21009                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21010                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21011                 }
21012                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21013                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21014                 }
21015                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21016         }
21017         return NDR_ERR_SUCCESS;
21018 }
21019
21020 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
21021 {
21022         uint32_t cntr_info_2;
21023         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
21024         ndr->depth++;
21025         if (flags & NDR_SET_VALUES) {
21026                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21027         }
21028         if (flags & NDR_IN) {
21029                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
21030                 ndr->depth++;
21031                 ndr_print_ptr(ndr, "servername", r->in.servername);
21032                 ndr->depth++;
21033                 if (r->in.servername) {
21034                         ndr_print_string(ndr, "servername", r->in.servername);
21035                 }
21036                 ndr->depth--;
21037                 ndr_print_ptr(ndr, "environment", r->in.environment);
21038                 ndr->depth++;
21039                 if (r->in.environment) {
21040                         ndr_print_string(ndr, "environment", r->in.environment);
21041                 }
21042                 ndr->depth--;
21043                 ndr_print_uint32(ndr, "level", r->in.level);
21044                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21045                 ndr->depth++;
21046                 if (r->in.buffer) {
21047                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21048                 }
21049                 ndr->depth--;
21050                 ndr_print_uint32(ndr, "offered", r->in.offered);
21051                 ndr->depth--;
21052         }
21053         if (flags & NDR_OUT) {
21054                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
21055                 ndr->depth++;
21056                 ndr_print_ptr(ndr, "count", r->out.count);
21057                 ndr->depth++;
21058                 ndr_print_uint32(ndr, "count", *r->out.count);
21059                 ndr->depth--;
21060                 ndr_print_ptr(ndr, "info", r->out.info);
21061                 ndr->depth++;
21062                 ndr_print_ptr(ndr, "info", *r->out.info);
21063                 ndr->depth++;
21064                 if (*r->out.info) {
21065                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21066                         ndr->depth++;
21067                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21068                                 char *idx_2=NULL;
21069                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21070                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21071                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21072                                         free(idx_2);
21073                                 }
21074                         }
21075                         ndr->depth--;
21076                 }
21077                 ndr->depth--;
21078                 ndr->depth--;
21079                 ndr_print_ptr(ndr, "needed", r->out.needed);
21080                 ndr->depth++;
21081                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21082                 ndr->depth--;
21083                 ndr_print_WERROR(ndr, "result", r->out.result);
21084                 ndr->depth--;
21085         }
21086         ndr->depth--;
21087 }
21088
21089 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21090 {
21091         if (flags & NDR_IN) {
21092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21093                 if (r->in.server) {
21094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21095                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21096                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21097                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21098                 }
21099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21100                 if (r->in.environment) {
21101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21102                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21104                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21105                 }
21106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21107                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21108                 if (r->in.buffer) {
21109                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21110                 }
21111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21112         }
21113         if (flags & NDR_OUT) {
21114                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21115                 if (r->out.info) {
21116                         {
21117                                 struct ndr_push *_ndr_info;
21118                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21119                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21120                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21121                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21122                         }
21123                 }
21124                 if (r->out.needed == NULL) {
21125                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21126                 }
21127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21128                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21129         }
21130         return NDR_ERR_SUCCESS;
21131 }
21132
21133 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
21134 {
21135         uint32_t _ptr_server;
21136         uint32_t _ptr_environment;
21137         uint32_t _ptr_buffer;
21138         uint32_t _ptr_info;
21139         TALLOC_CTX *_mem_save_server_0;
21140         TALLOC_CTX *_mem_save_environment_0;
21141         TALLOC_CTX *_mem_save_buffer_0;
21142         TALLOC_CTX *_mem_save_info_0;
21143         TALLOC_CTX *_mem_save_needed_0;
21144         if (flags & NDR_IN) {
21145                 ZERO_STRUCT(r->out);
21146
21147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21148                 if (_ptr_server) {
21149                         NDR_PULL_ALLOC(ndr, r->in.server);
21150                 } else {
21151                         r->in.server = NULL;
21152                 }
21153                 if (r->in.server) {
21154                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21155                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21156                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21157                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21158                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21159                                 return 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));
21160                         }
21161                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21162                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21163                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21164                 }
21165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21166                 if (_ptr_environment) {
21167                         NDR_PULL_ALLOC(ndr, r->in.environment);
21168                 } else {
21169                         r->in.environment = NULL;
21170                 }
21171                 if (r->in.environment) {
21172                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21173                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21174                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21175                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21176                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21177                                 return 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));
21178                         }
21179                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21180                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21181                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21182                 }
21183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21184                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21185                 if (_ptr_buffer) {
21186                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21187                 } else {
21188                         r->in.buffer = NULL;
21189                 }
21190                 if (r->in.buffer) {
21191                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21192                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21193                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21194                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21195                 }
21196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21197                 NDR_PULL_ALLOC(ndr, r->out.needed);
21198                 ZERO_STRUCTP(r->out.needed);
21199         }
21200         if (flags & NDR_OUT) {
21201                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21202                 if (_ptr_info) {
21203                         NDR_PULL_ALLOC(ndr, r->out.info);
21204                 } else {
21205                         r->out.info = NULL;
21206                 }
21207                 if (r->out.info) {
21208                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21209                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21210                         {
21211                                 struct ndr_pull *_ndr_info;
21212                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21213                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21214                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21215                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21216                         }
21217                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21218                 }
21219                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21220                         NDR_PULL_ALLOC(ndr, r->out.needed);
21221                 }
21222                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21223                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21224                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21225                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21226                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21227         }
21228         return NDR_ERR_SUCCESS;
21229 }
21230
21231 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21232 {
21233         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
21234         ndr->depth++;
21235         if (flags & NDR_SET_VALUES) {
21236                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21237         }
21238         if (flags & NDR_IN) {
21239                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
21240                 ndr->depth++;
21241                 ndr_print_ptr(ndr, "server", r->in.server);
21242                 ndr->depth++;
21243                 if (r->in.server) {
21244                         ndr_print_string(ndr, "server", r->in.server);
21245                 }
21246                 ndr->depth--;
21247                 ndr_print_ptr(ndr, "environment", r->in.environment);
21248                 ndr->depth++;
21249                 if (r->in.environment) {
21250                         ndr_print_string(ndr, "environment", r->in.environment);
21251                 }
21252                 ndr->depth--;
21253                 ndr_print_uint32(ndr, "level", r->in.level);
21254                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21255                 ndr->depth++;
21256                 if (r->in.buffer) {
21257                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21258                 }
21259                 ndr->depth--;
21260                 ndr_print_uint32(ndr, "offered", r->in.offered);
21261                 ndr->depth--;
21262         }
21263         if (flags & NDR_OUT) {
21264                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
21265                 ndr->depth++;
21266                 ndr_print_ptr(ndr, "info", r->out.info);
21267                 ndr->depth++;
21268                 if (r->out.info) {
21269                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21270                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
21271                 }
21272                 ndr->depth--;
21273                 ndr_print_ptr(ndr, "needed", r->out.needed);
21274                 ndr->depth++;
21275                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21276                 ndr->depth--;
21277                 ndr_print_WERROR(ndr, "result", r->out.result);
21278                 ndr->depth--;
21279         }
21280         ndr->depth--;
21281 }
21282
21283 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
21284 {
21285         if (flags & NDR_IN) {
21286                 if (r->in.handle == NULL) {
21287                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21288                 }
21289                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21291                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21292                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21293         }
21294         if (flags & NDR_OUT) {
21295                 if (r->out.job_id == NULL) {
21296                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21297                 }
21298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
21299                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21300         }
21301         return NDR_ERR_SUCCESS;
21302 }
21303
21304 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
21305 {
21306         TALLOC_CTX *_mem_save_handle_0;
21307         TALLOC_CTX *_mem_save_job_id_0;
21308         if (flags & NDR_IN) {
21309                 ZERO_STRUCT(r->out);
21310
21311                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21312                         NDR_PULL_ALLOC(ndr, r->in.handle);
21313                 }
21314                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21315                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21316                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21317                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21319                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21320                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21321                 NDR_PULL_ALLOC(ndr, r->out.job_id);
21322                 ZERO_STRUCTP(r->out.job_id);
21323         }
21324         if (flags & NDR_OUT) {
21325                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21326                         NDR_PULL_ALLOC(ndr, r->out.job_id);
21327                 }
21328                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
21329                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
21330                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
21331                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
21332                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21333         }
21334         return NDR_ERR_SUCCESS;
21335 }
21336
21337 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
21338 {
21339         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
21340         ndr->depth++;
21341         if (flags & NDR_SET_VALUES) {
21342                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21343         }
21344         if (flags & NDR_IN) {
21345                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
21346                 ndr->depth++;
21347                 ndr_print_ptr(ndr, "handle", r->in.handle);
21348                 ndr->depth++;
21349                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21350                 ndr->depth--;
21351                 ndr_print_uint32(ndr, "level", r->in.level);
21352                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21353                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
21354                 ndr->depth--;
21355         }
21356         if (flags & NDR_OUT) {
21357                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
21358                 ndr->depth++;
21359                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
21360                 ndr->depth++;
21361                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
21362                 ndr->depth--;
21363                 ndr_print_WERROR(ndr, "result", r->out.result);
21364                 ndr->depth--;
21365         }
21366         ndr->depth--;
21367 }
21368
21369 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
21370 {
21371         if (flags & NDR_IN) {
21372                 if (r->in.handle == NULL) {
21373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21374                 }
21375                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21376         }
21377         if (flags & NDR_OUT) {
21378                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21379         }
21380         return NDR_ERR_SUCCESS;
21381 }
21382
21383 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
21384 {
21385         TALLOC_CTX *_mem_save_handle_0;
21386         if (flags & NDR_IN) {
21387                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21388                         NDR_PULL_ALLOC(ndr, r->in.handle);
21389                 }
21390                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21391                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21392                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21393                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21394         }
21395         if (flags & NDR_OUT) {
21396                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21397         }
21398         return NDR_ERR_SUCCESS;
21399 }
21400
21401 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
21402 {
21403         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
21404         ndr->depth++;
21405         if (flags & NDR_SET_VALUES) {
21406                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21407         }
21408         if (flags & NDR_IN) {
21409                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
21410                 ndr->depth++;
21411                 ndr_print_ptr(ndr, "handle", r->in.handle);
21412                 ndr->depth++;
21413                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21414                 ndr->depth--;
21415                 ndr->depth--;
21416         }
21417         if (flags & NDR_OUT) {
21418                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21419                 ndr->depth++;
21420                 ndr_print_WERROR(ndr, "result", r->out.result);
21421                 ndr->depth--;
21422         }
21423         ndr->depth--;
21424 }
21425
21426 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21427 {
21428         if (flags & NDR_IN) {
21429                 if (r->in.handle == NULL) {
21430                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21431                 }
21432                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21433                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21435         }
21436         if (flags & NDR_OUT) {
21437                 if (r->out.num_written == NULL) {
21438                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21439                 }
21440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21441                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21442         }
21443         return NDR_ERR_SUCCESS;
21444 }
21445
21446 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21447 {
21448         TALLOC_CTX *_mem_save_handle_0;
21449         TALLOC_CTX *_mem_save_num_written_0;
21450         if (flags & NDR_IN) {
21451                 ZERO_STRUCT(r->out);
21452
21453                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21454                         NDR_PULL_ALLOC(ndr, r->in.handle);
21455                 }
21456                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21457                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21458                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21459                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21460                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21461                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21462                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21463                 ZERO_STRUCTP(r->out.num_written);
21464         }
21465         if (flags & NDR_OUT) {
21466                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21467                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21468                 }
21469                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21470                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21472                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21473                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21474         }
21475         return NDR_ERR_SUCCESS;
21476 }
21477
21478 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21479 {
21480         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21481         ndr->depth++;
21482         if (flags & NDR_SET_VALUES) {
21483                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21484         }
21485         if (flags & NDR_IN) {
21486                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21487                 ndr->depth++;
21488                 ndr_print_ptr(ndr, "handle", r->in.handle);
21489                 ndr->depth++;
21490                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21491                 ndr->depth--;
21492                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21493                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21494                 ndr->depth--;
21495         }
21496         if (flags & NDR_OUT) {
21497                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21498                 ndr->depth++;
21499                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21500                 ndr->depth++;
21501                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21502                 ndr->depth--;
21503                 ndr_print_WERROR(ndr, "result", r->out.result);
21504                 ndr->depth--;
21505         }
21506         ndr->depth--;
21507 }
21508
21509 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21510 {
21511         if (flags & NDR_IN) {
21512                 if (r->in.handle == NULL) {
21513                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21514                 }
21515                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21516         }
21517         if (flags & NDR_OUT) {
21518                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21519         }
21520         return NDR_ERR_SUCCESS;
21521 }
21522
21523 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21524 {
21525         TALLOC_CTX *_mem_save_handle_0;
21526         if (flags & NDR_IN) {
21527                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21528                         NDR_PULL_ALLOC(ndr, r->in.handle);
21529                 }
21530                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21531                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21532                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21533                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21534         }
21535         if (flags & NDR_OUT) {
21536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21537         }
21538         return NDR_ERR_SUCCESS;
21539 }
21540
21541 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21542 {
21543         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21544         ndr->depth++;
21545         if (flags & NDR_SET_VALUES) {
21546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21547         }
21548         if (flags & NDR_IN) {
21549                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21550                 ndr->depth++;
21551                 ndr_print_ptr(ndr, "handle", r->in.handle);
21552                 ndr->depth++;
21553                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21554                 ndr->depth--;
21555                 ndr->depth--;
21556         }
21557         if (flags & NDR_OUT) {
21558                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21559                 ndr->depth++;
21560                 ndr_print_WERROR(ndr, "result", r->out.result);
21561                 ndr->depth--;
21562         }
21563         ndr->depth--;
21564 }
21565
21566 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21567 {
21568         if (flags & NDR_IN) {
21569                 if (r->in.handle == NULL) {
21570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21571                 }
21572                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21573         }
21574         if (flags & NDR_OUT) {
21575                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21576         }
21577         return NDR_ERR_SUCCESS;
21578 }
21579
21580 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21581 {
21582         TALLOC_CTX *_mem_save_handle_0;
21583         if (flags & NDR_IN) {
21584                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21585                         NDR_PULL_ALLOC(ndr, r->in.handle);
21586                 }
21587                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21588                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21589                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21590                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21591         }
21592         if (flags & NDR_OUT) {
21593                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21594         }
21595         return NDR_ERR_SUCCESS;
21596 }
21597
21598 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21599 {
21600         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21601         ndr->depth++;
21602         if (flags & NDR_SET_VALUES) {
21603                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21604         }
21605         if (flags & NDR_IN) {
21606                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21607                 ndr->depth++;
21608                 ndr_print_ptr(ndr, "handle", r->in.handle);
21609                 ndr->depth++;
21610                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21611                 ndr->depth--;
21612                 ndr->depth--;
21613         }
21614         if (flags & NDR_OUT) {
21615                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21616                 ndr->depth++;
21617                 ndr_print_WERROR(ndr, "result", r->out.result);
21618                 ndr->depth--;
21619         }
21620         ndr->depth--;
21621 }
21622
21623 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21624 {
21625         if (flags & NDR_IN) {
21626                 if (r->in.handle == NULL) {
21627                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21628                 }
21629                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21631         }
21632         if (flags & NDR_OUT) {
21633                 if (r->out.data == NULL) {
21634                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21635                 }
21636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21637                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21638                 if (r->out._data_size == NULL) {
21639                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21640                 }
21641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21642                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21643         }
21644         return NDR_ERR_SUCCESS;
21645 }
21646
21647 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21648 {
21649         TALLOC_CTX *_mem_save_handle_0;
21650         TALLOC_CTX *_mem_save__data_size_0;
21651         if (flags & NDR_IN) {
21652                 ZERO_STRUCT(r->out);
21653
21654                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21655                         NDR_PULL_ALLOC(ndr, r->in.handle);
21656                 }
21657                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21658                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21659                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21660                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21662                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21663                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21664                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21665                 ZERO_STRUCTP(r->out._data_size);
21666         }
21667         if (flags & NDR_OUT) {
21668                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21669                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21670                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21671                 }
21672                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21673                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21674                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21675                 }
21676                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21677                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21679                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21680                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21681                 if (r->out.data) {
21682                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21683                 }
21684         }
21685         return NDR_ERR_SUCCESS;
21686 }
21687
21688 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21689 {
21690         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21691         ndr->depth++;
21692         if (flags & NDR_SET_VALUES) {
21693                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21694         }
21695         if (flags & NDR_IN) {
21696                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21697                 ndr->depth++;
21698                 ndr_print_ptr(ndr, "handle", r->in.handle);
21699                 ndr->depth++;
21700                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21701                 ndr->depth--;
21702                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21703                 ndr->depth--;
21704         }
21705         if (flags & NDR_OUT) {
21706                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21707                 ndr->depth++;
21708                 ndr_print_ptr(ndr, "data", r->out.data);
21709                 ndr->depth++;
21710                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21711                 ndr->depth--;
21712                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21713                 ndr->depth++;
21714                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21715                 ndr->depth--;
21716                 ndr_print_WERROR(ndr, "result", r->out.result);
21717                 ndr->depth--;
21718         }
21719         ndr->depth--;
21720 }
21721
21722 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21723 {
21724         if (flags & NDR_IN) {
21725                 if (r->in.handle == NULL) {
21726                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21727                 }
21728                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21729         }
21730         if (flags & NDR_OUT) {
21731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21732         }
21733         return NDR_ERR_SUCCESS;
21734 }
21735
21736 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21737 {
21738         TALLOC_CTX *_mem_save_handle_0;
21739         if (flags & NDR_IN) {
21740                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21741                         NDR_PULL_ALLOC(ndr, r->in.handle);
21742                 }
21743                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21744                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21745                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21746                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21747         }
21748         if (flags & NDR_OUT) {
21749                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21750         }
21751         return NDR_ERR_SUCCESS;
21752 }
21753
21754 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21755 {
21756         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21757         ndr->depth++;
21758         if (flags & NDR_SET_VALUES) {
21759                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21760         }
21761         if (flags & NDR_IN) {
21762                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21763                 ndr->depth++;
21764                 ndr_print_ptr(ndr, "handle", r->in.handle);
21765                 ndr->depth++;
21766                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21767                 ndr->depth--;
21768                 ndr->depth--;
21769         }
21770         if (flags & NDR_OUT) {
21771                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21772                 ndr->depth++;
21773                 ndr_print_WERROR(ndr, "result", r->out.result);
21774                 ndr->depth--;
21775         }
21776         ndr->depth--;
21777 }
21778
21779 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21780 {
21781         if (flags & NDR_IN) {
21782                 if (r->in.handle == NULL) {
21783                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21784                 }
21785                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21787                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21788                 if (r->in.buffer) {
21789                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21790                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21791                 }
21792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21793         }
21794         if (flags & NDR_OUT) {
21795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21796                 if (r->out.buffer) {
21797                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21798                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21799                 }
21800                 if (r->out.needed == NULL) {
21801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21802                 }
21803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21804                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21805         }
21806         return NDR_ERR_SUCCESS;
21807 }
21808
21809 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21810 {
21811         uint32_t _ptr_buffer;
21812         TALLOC_CTX *_mem_save_handle_0;
21813         TALLOC_CTX *_mem_save_buffer_0;
21814         TALLOC_CTX *_mem_save_needed_0;
21815         if (flags & NDR_IN) {
21816                 ZERO_STRUCT(r->out);
21817
21818                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21819                         NDR_PULL_ALLOC(ndr, r->in.handle);
21820                 }
21821                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21822                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21823                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21824                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21826                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21827                 if (_ptr_buffer) {
21828                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21829                 } else {
21830                         r->in.buffer = NULL;
21831                 }
21832                 if (r->in.buffer) {
21833                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21834                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21835                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21836                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21837                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21839                 }
21840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21841                 NDR_PULL_ALLOC(ndr, r->out.needed);
21842                 ZERO_STRUCTP(r->out.needed);
21843                 if (r->in.buffer) {
21844                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21845                 }
21846         }
21847         if (flags & NDR_OUT) {
21848                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21849                 if (_ptr_buffer) {
21850                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21851                 } else {
21852                         r->out.buffer = NULL;
21853                 }
21854                 if (r->out.buffer) {
21855                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21856                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21857                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21858                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21859                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21861                 }
21862                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21863                         NDR_PULL_ALLOC(ndr, r->out.needed);
21864                 }
21865                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21866                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21868                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21869                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21870                 if (r->out.buffer) {
21871                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21872                 }
21873         }
21874         return NDR_ERR_SUCCESS;
21875 }
21876
21877 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21878 {
21879         ndr_print_struct(ndr, name, "spoolss_AddJob");
21880         ndr->depth++;
21881         if (flags & NDR_SET_VALUES) {
21882                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21883         }
21884         if (flags & NDR_IN) {
21885                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21886                 ndr->depth++;
21887                 ndr_print_ptr(ndr, "handle", r->in.handle);
21888                 ndr->depth++;
21889                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21890                 ndr->depth--;
21891                 ndr_print_uint32(ndr, "level", r->in.level);
21892                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21893                 ndr->depth++;
21894                 if (r->in.buffer) {
21895                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21896                 }
21897                 ndr->depth--;
21898                 ndr_print_uint32(ndr, "offered", r->in.offered);
21899                 ndr->depth--;
21900         }
21901         if (flags & NDR_OUT) {
21902                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21903                 ndr->depth++;
21904                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21905                 ndr->depth++;
21906                 if (r->out.buffer) {
21907                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21908                 }
21909                 ndr->depth--;
21910                 ndr_print_ptr(ndr, "needed", r->out.needed);
21911                 ndr->depth++;
21912                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21913                 ndr->depth--;
21914                 ndr_print_WERROR(ndr, "result", r->out.result);
21915                 ndr->depth--;
21916         }
21917         ndr->depth--;
21918 }
21919
21920 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21921 {
21922         if (flags & NDR_IN) {
21923                 if (r->in.handle == NULL) {
21924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21925                 }
21926                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21927                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21928         }
21929         if (flags & NDR_OUT) {
21930                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21931         }
21932         return NDR_ERR_SUCCESS;
21933 }
21934
21935 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21936 {
21937         TALLOC_CTX *_mem_save_handle_0;
21938         if (flags & NDR_IN) {
21939                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21940                         NDR_PULL_ALLOC(ndr, r->in.handle);
21941                 }
21942                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21943                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21944                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21945                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21947         }
21948         if (flags & NDR_OUT) {
21949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21950         }
21951         return NDR_ERR_SUCCESS;
21952 }
21953
21954 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21955 {
21956         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21957         ndr->depth++;
21958         if (flags & NDR_SET_VALUES) {
21959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21960         }
21961         if (flags & NDR_IN) {
21962                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21963                 ndr->depth++;
21964                 ndr_print_ptr(ndr, "handle", r->in.handle);
21965                 ndr->depth++;
21966                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21967                 ndr->depth--;
21968                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21969                 ndr->depth--;
21970         }
21971         if (flags & NDR_OUT) {
21972                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21973                 ndr->depth++;
21974                 ndr_print_WERROR(ndr, "result", r->out.result);
21975                 ndr->depth--;
21976         }
21977         ndr->depth--;
21978 }
21979
21980 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21981 {
21982         if (flags & NDR_IN) {
21983                 if (r->in.handle == NULL) {
21984                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21985                 }
21986                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21990                 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));
21991                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21992         }
21993         if (flags & NDR_OUT) {
21994                 if (r->out.type == NULL) {
21995                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21996                 }
21997                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
21998                 if (r->out.data == NULL) {
21999                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22000                 }
22001                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
22002                 if (r->out.needed == NULL) {
22003                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22004                 }
22005                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22006                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22007         }
22008         return NDR_ERR_SUCCESS;
22009 }
22010
22011 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
22012 {
22013         TALLOC_CTX *_mem_save_handle_0;
22014         TALLOC_CTX *_mem_save_type_0;
22015         TALLOC_CTX *_mem_save_data_0;
22016         TALLOC_CTX *_mem_save_needed_0;
22017         if (flags & NDR_IN) {
22018                 ZERO_STRUCT(r->out);
22019
22020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22021                         NDR_PULL_ALLOC(ndr, r->in.handle);
22022                 }
22023                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22024                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22025                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22027                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22028                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22029                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22030                         return 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));
22031                 }
22032                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22033                 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));
22034                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22035                 NDR_PULL_ALLOC(ndr, r->out.type);
22036                 ZERO_STRUCTP(r->out.type);
22037                 NDR_PULL_ALLOC(ndr, r->out.data);
22038                 ZERO_STRUCTP(r->out.data);
22039                 NDR_PULL_ALLOC(ndr, r->out.needed);
22040                 ZERO_STRUCTP(r->out.needed);
22041         }
22042         if (flags & NDR_OUT) {
22043                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22044                         NDR_PULL_ALLOC(ndr, r->out.type);
22045                 }
22046                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
22047                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
22048                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
22049                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
22050                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22051                         NDR_PULL_ALLOC(ndr, r->out.data);
22052                 }
22053                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22054                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22055                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
22056                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22057                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22058                         NDR_PULL_ALLOC(ndr, r->out.needed);
22059                 }
22060                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22061                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22063                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22064                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22065         }
22066         return NDR_ERR_SUCCESS;
22067 }
22068
22069 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
22070 {
22071         if (flags & NDR_IN) {
22072                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22073         }
22074         if (flags & NDR_OUT) {
22075                 if (r->out.data == NULL) {
22076                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22077                 }
22078                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22079                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22080         }
22081         return NDR_ERR_SUCCESS;
22082 }
22083
22084 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
22085 {
22086         TALLOC_CTX *_mem_save_data_0;
22087         if (flags & NDR_IN) {
22088                 ZERO_STRUCT(r->out);
22089
22090                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22091                 NDR_PULL_ALLOC(ndr, r->out.data);
22092                 ZERO_STRUCTP(r->out.data);
22093         }
22094         if (flags & NDR_OUT) {
22095                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22096                         NDR_PULL_ALLOC(ndr, r->out.data);
22097                 }
22098                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22099                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22100                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
22101                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22102                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22103         }
22104         return NDR_ERR_SUCCESS;
22105 }
22106
22107 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
22108 {
22109         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
22110         ndr->depth++;
22111         if (flags & NDR_SET_VALUES) {
22112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22113         }
22114         if (flags & NDR_IN) {
22115                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
22116                 ndr->depth++;
22117                 ndr_print_ptr(ndr, "handle", r->in.handle);
22118                 ndr->depth++;
22119                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22120                 ndr->depth--;
22121                 ndr_print_string(ndr, "value_name", r->in.value_name);
22122                 ndr_print_uint32(ndr, "offered", r->in.offered);
22123                 ndr->depth--;
22124         }
22125         if (flags & NDR_OUT) {
22126                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
22127                 ndr->depth++;
22128                 ndr_print_ptr(ndr, "type", r->out.type);
22129                 ndr->depth++;
22130                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
22131                 ndr->depth--;
22132                 ndr_print_ptr(ndr, "data", r->out.data);
22133                 ndr->depth++;
22134                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
22135                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
22136                 ndr->depth--;
22137                 ndr_print_ptr(ndr, "needed", r->out.needed);
22138                 ndr->depth++;
22139                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22140                 ndr->depth--;
22141                 ndr_print_WERROR(ndr, "result", r->out.result);
22142                 ndr->depth--;
22143         }
22144         ndr->depth--;
22145 }
22146
22147 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
22148 {
22149         if (flags & NDR_IN) {
22150                 if (r->in.handle == NULL) {
22151                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22152                 }
22153                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22154                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22155                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22157                 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));
22158                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22159                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
22161         }
22162         if (flags & NDR_OUT) {
22163                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22164         }
22165         return NDR_ERR_SUCCESS;
22166 }
22167
22168 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
22169 {
22170         if (flags & NDR_IN) {
22171                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22172         }
22173         if (flags & NDR_OUT) {
22174                 if (r->out.data == NULL) {
22175                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22176                 }
22177                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22178                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22179         }
22180         return NDR_ERR_SUCCESS;
22181 }
22182
22183 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
22184 {
22185         TALLOC_CTX *_mem_save_handle_0;
22186         if (flags & NDR_IN) {
22187                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22188                         NDR_PULL_ALLOC(ndr, r->in.handle);
22189                 }
22190                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22191                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22192                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22193                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22194                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22195                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22196                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22197                         return 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));
22198                 }
22199                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22200                 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));
22201                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22202                 {
22203                         struct ndr_pull *_ndr_data;
22204                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
22205                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
22206                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
22207                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
22208                 }
22209                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
22210         }
22211         if (flags & NDR_OUT) {
22212                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22213         }
22214         return NDR_ERR_SUCCESS;
22215 }
22216
22217 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
22218 {
22219         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
22220         ndr->depth++;
22221         if (flags & NDR_SET_VALUES) {
22222                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22223         }
22224         if (flags & NDR_IN) {
22225                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
22226                 ndr->depth++;
22227                 ndr_print_ptr(ndr, "handle", r->in.handle);
22228                 ndr->depth++;
22229                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22230                 ndr->depth--;
22231                 ndr_print_string(ndr, "value_name", r->in.value_name);
22232                 ndr_print_winreg_Type(ndr, "type", r->in.type);
22233                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
22234                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
22235                 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);
22236                 ndr->depth--;
22237         }
22238         if (flags & NDR_OUT) {
22239                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
22240                 ndr->depth++;
22241                 ndr_print_WERROR(ndr, "result", r->out.result);
22242                 ndr->depth--;
22243         }
22244         ndr->depth--;
22245 }
22246
22247 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
22248 {
22249         if (flags & NDR_IN) {
22250         }
22251         if (flags & NDR_OUT) {
22252                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22253         }
22254         return NDR_ERR_SUCCESS;
22255 }
22256
22257 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
22258 {
22259         if (flags & NDR_IN) {
22260         }
22261         if (flags & NDR_OUT) {
22262                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22263         }
22264         return NDR_ERR_SUCCESS;
22265 }
22266
22267 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
22268 {
22269         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
22270         ndr->depth++;
22271         if (flags & NDR_SET_VALUES) {
22272                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22273         }
22274         if (flags & NDR_IN) {
22275                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
22276                 ndr->depth++;
22277                 ndr->depth--;
22278         }
22279         if (flags & NDR_OUT) {
22280                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
22281                 ndr->depth++;
22282                 ndr_print_WERROR(ndr, "result", r->out.result);
22283                 ndr->depth--;
22284         }
22285         ndr->depth--;
22286 }
22287
22288 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
22289 {
22290         if (flags & NDR_IN) {
22291                 if (r->in.handle == NULL) {
22292                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22293                 }
22294                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22295         }
22296         if (flags & NDR_OUT) {
22297                 if (r->out.handle == NULL) {
22298                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22299                 }
22300                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22301                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22302         }
22303         return NDR_ERR_SUCCESS;
22304 }
22305
22306 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
22307 {
22308         TALLOC_CTX *_mem_save_handle_0;
22309         if (flags & NDR_IN) {
22310                 ZERO_STRUCT(r->out);
22311
22312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22313                         NDR_PULL_ALLOC(ndr, r->in.handle);
22314                 }
22315                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22316                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22317                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22319                 NDR_PULL_ALLOC(ndr, r->out.handle);
22320                 *r->out.handle = *r->in.handle;
22321         }
22322         if (flags & NDR_OUT) {
22323                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22324                         NDR_PULL_ALLOC(ndr, r->out.handle);
22325                 }
22326                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22327                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22328                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22329                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22330                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22331         }
22332         return NDR_ERR_SUCCESS;
22333 }
22334
22335 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
22336 {
22337         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
22338         ndr->depth++;
22339         if (flags & NDR_SET_VALUES) {
22340                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22341         }
22342         if (flags & NDR_IN) {
22343                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
22344                 ndr->depth++;
22345                 ndr_print_ptr(ndr, "handle", r->in.handle);
22346                 ndr->depth++;
22347                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22348                 ndr->depth--;
22349                 ndr->depth--;
22350         }
22351         if (flags & NDR_OUT) {
22352                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
22353                 ndr->depth++;
22354                 ndr_print_ptr(ndr, "handle", r->out.handle);
22355                 ndr->depth++;
22356                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22357                 ndr->depth--;
22358                 ndr_print_WERROR(ndr, "result", r->out.result);
22359                 ndr->depth--;
22360         }
22361         ndr->depth--;
22362 }
22363
22364 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
22365 {
22366         if (flags & NDR_IN) {
22367                 if (r->in.handle == NULL) {
22368                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22369                 }
22370                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22372                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22373                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22374         }
22375         if (flags & NDR_OUT) {
22376                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22377         }
22378         return NDR_ERR_SUCCESS;
22379 }
22380
22381 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
22382 {
22383         TALLOC_CTX *_mem_save_handle_0;
22384         if (flags & NDR_IN) {
22385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22386                         NDR_PULL_ALLOC(ndr, r->in.handle);
22387                 }
22388                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22389                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22390                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22393                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22394                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22395         }
22396         if (flags & NDR_OUT) {
22397                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22398         }
22399         return NDR_ERR_SUCCESS;
22400 }
22401
22402 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
22403 {
22404         ndr_print_struct(ndr, name, "spoolss_AddForm");
22405         ndr->depth++;
22406         if (flags & NDR_SET_VALUES) {
22407                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22408         }
22409         if (flags & NDR_IN) {
22410                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
22411                 ndr->depth++;
22412                 ndr_print_ptr(ndr, "handle", r->in.handle);
22413                 ndr->depth++;
22414                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22415                 ndr->depth--;
22416                 ndr_print_uint32(ndr, "level", r->in.level);
22417                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22418                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22419                 ndr->depth--;
22420         }
22421         if (flags & NDR_OUT) {
22422                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22423                 ndr->depth++;
22424                 ndr_print_WERROR(ndr, "result", r->out.result);
22425                 ndr->depth--;
22426         }
22427         ndr->depth--;
22428 }
22429
22430 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22431 {
22432         if (flags & NDR_IN) {
22433                 if (r->in.handle == NULL) {
22434                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22435                 }
22436                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22440                 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));
22441         }
22442         if (flags & NDR_OUT) {
22443                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22444         }
22445         return NDR_ERR_SUCCESS;
22446 }
22447
22448 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22449 {
22450         TALLOC_CTX *_mem_save_handle_0;
22451         if (flags & NDR_IN) {
22452                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22453                         NDR_PULL_ALLOC(ndr, r->in.handle);
22454                 }
22455                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22456                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22457                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22459                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22460                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22461                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22462                         return 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));
22463                 }
22464                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22465                 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));
22466         }
22467         if (flags & NDR_OUT) {
22468                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22469         }
22470         return NDR_ERR_SUCCESS;
22471 }
22472
22473 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22474 {
22475         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22476         ndr->depth++;
22477         if (flags & NDR_SET_VALUES) {
22478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22479         }
22480         if (flags & NDR_IN) {
22481                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22482                 ndr->depth++;
22483                 ndr_print_ptr(ndr, "handle", r->in.handle);
22484                 ndr->depth++;
22485                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22486                 ndr->depth--;
22487                 ndr_print_string(ndr, "form_name", r->in.form_name);
22488                 ndr->depth--;
22489         }
22490         if (flags & NDR_OUT) {
22491                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22492                 ndr->depth++;
22493                 ndr_print_WERROR(ndr, "result", r->out.result);
22494                 ndr->depth--;
22495         }
22496         ndr->depth--;
22497 }
22498
22499 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22500 {
22501         if (flags & NDR_IN) {
22502                 if (r->in.handle == NULL) {
22503                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22504                 }
22505                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22506                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22509                 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));
22510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22511                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22512                 if (r->in.buffer) {
22513                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22514                 }
22515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22516         }
22517         if (flags & NDR_OUT) {
22518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22519                 if (r->out.info) {
22520                         {
22521                                 struct ndr_push *_ndr_info;
22522                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22523                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22524                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22525                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22526                         }
22527                 }
22528                 if (r->out.needed == NULL) {
22529                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22530                 }
22531                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22532                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22533         }
22534         return NDR_ERR_SUCCESS;
22535 }
22536
22537 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22538 {
22539         uint32_t _ptr_buffer;
22540         uint32_t _ptr_info;
22541         TALLOC_CTX *_mem_save_handle_0;
22542         TALLOC_CTX *_mem_save_buffer_0;
22543         TALLOC_CTX *_mem_save_info_0;
22544         TALLOC_CTX *_mem_save_needed_0;
22545         if (flags & NDR_IN) {
22546                 ZERO_STRUCT(r->out);
22547
22548                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22549                         NDR_PULL_ALLOC(ndr, r->in.handle);
22550                 }
22551                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22552                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22553                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22554                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22555                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22556                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22557                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22558                         return 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));
22559                 }
22560                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22561                 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));
22562                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22563                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22564                 if (_ptr_buffer) {
22565                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22566                 } else {
22567                         r->in.buffer = NULL;
22568                 }
22569                 if (r->in.buffer) {
22570                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22571                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22572                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22573                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22574                 }
22575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22576                 NDR_PULL_ALLOC(ndr, r->out.needed);
22577                 ZERO_STRUCTP(r->out.needed);
22578         }
22579         if (flags & NDR_OUT) {
22580                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22581                 if (_ptr_info) {
22582                         NDR_PULL_ALLOC(ndr, r->out.info);
22583                 } else {
22584                         r->out.info = NULL;
22585                 }
22586                 if (r->out.info) {
22587                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22588                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22589                         {
22590                                 struct ndr_pull *_ndr_info;
22591                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22592                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22593                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22594                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22595                         }
22596                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22597                 }
22598                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22599                         NDR_PULL_ALLOC(ndr, r->out.needed);
22600                 }
22601                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22602                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22603                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22604                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22605                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22606         }
22607         return NDR_ERR_SUCCESS;
22608 }
22609
22610 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22611 {
22612         ndr_print_struct(ndr, name, "spoolss_GetForm");
22613         ndr->depth++;
22614         if (flags & NDR_SET_VALUES) {
22615                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22616         }
22617         if (flags & NDR_IN) {
22618                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22619                 ndr->depth++;
22620                 ndr_print_ptr(ndr, "handle", r->in.handle);
22621                 ndr->depth++;
22622                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22623                 ndr->depth--;
22624                 ndr_print_string(ndr, "form_name", r->in.form_name);
22625                 ndr_print_uint32(ndr, "level", r->in.level);
22626                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22627                 ndr->depth++;
22628                 if (r->in.buffer) {
22629                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22630                 }
22631                 ndr->depth--;
22632                 ndr_print_uint32(ndr, "offered", r->in.offered);
22633                 ndr->depth--;
22634         }
22635         if (flags & NDR_OUT) {
22636                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22637                 ndr->depth++;
22638                 ndr_print_ptr(ndr, "info", r->out.info);
22639                 ndr->depth++;
22640                 if (r->out.info) {
22641                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22642                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22643                 }
22644                 ndr->depth--;
22645                 ndr_print_ptr(ndr, "needed", r->out.needed);
22646                 ndr->depth++;
22647                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22648                 ndr->depth--;
22649                 ndr_print_WERROR(ndr, "result", r->out.result);
22650                 ndr->depth--;
22651         }
22652         ndr->depth--;
22653 }
22654
22655 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22656 {
22657         if (flags & NDR_IN) {
22658                 if (r->in.handle == NULL) {
22659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22660                 }
22661                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22665                 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));
22666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22667                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22668                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22669         }
22670         if (flags & NDR_OUT) {
22671                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22672         }
22673         return NDR_ERR_SUCCESS;
22674 }
22675
22676 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22677 {
22678         TALLOC_CTX *_mem_save_handle_0;
22679         if (flags & NDR_IN) {
22680                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22681                         NDR_PULL_ALLOC(ndr, r->in.handle);
22682                 }
22683                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22684                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22685                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22686                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22687                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22688                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22689                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22690                         return 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));
22691                 }
22692                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22693                 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));
22694                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22695                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22696                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22697         }
22698         if (flags & NDR_OUT) {
22699                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22700         }
22701         return NDR_ERR_SUCCESS;
22702 }
22703
22704 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22705 {
22706         ndr_print_struct(ndr, name, "spoolss_SetForm");
22707         ndr->depth++;
22708         if (flags & NDR_SET_VALUES) {
22709                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22710         }
22711         if (flags & NDR_IN) {
22712                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22713                 ndr->depth++;
22714                 ndr_print_ptr(ndr, "handle", r->in.handle);
22715                 ndr->depth++;
22716                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22717                 ndr->depth--;
22718                 ndr_print_string(ndr, "form_name", r->in.form_name);
22719                 ndr_print_uint32(ndr, "level", r->in.level);
22720                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22721                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22722                 ndr->depth--;
22723         }
22724         if (flags & NDR_OUT) {
22725                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22726                 ndr->depth++;
22727                 ndr_print_WERROR(ndr, "result", r->out.result);
22728                 ndr->depth--;
22729         }
22730         ndr->depth--;
22731 }
22732
22733 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22734 {
22735         if (flags & NDR_IN) {
22736                 if (r->in.handle == NULL) {
22737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22738                 }
22739                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22741                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22742                 if (r->in.buffer) {
22743                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22744                 }
22745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22746         }
22747         if (flags & NDR_OUT) {
22748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22749                 if (r->out.info) {
22750                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22751                 }
22752                 if (r->out.needed == NULL) {
22753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22754                 }
22755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22756                 if (r->out.count == NULL) {
22757                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22758                 }
22759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22760                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22761         }
22762         return NDR_ERR_SUCCESS;
22763 }
22764
22765 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22766 {
22767         uint32_t _ptr_buffer;
22768         uint32_t _ptr_info;
22769         TALLOC_CTX *_mem_save_handle_0;
22770         TALLOC_CTX *_mem_save_buffer_0;
22771         TALLOC_CTX *_mem_save_info_0;
22772         TALLOC_CTX *_mem_save_needed_0;
22773         TALLOC_CTX *_mem_save_count_0;
22774         if (flags & NDR_IN) {
22775                 ZERO_STRUCT(r->out);
22776
22777                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22778                         NDR_PULL_ALLOC(ndr, r->in.handle);
22779                 }
22780                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22781                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22782                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22783                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22785                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22786                 if (_ptr_buffer) {
22787                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22788                 } else {
22789                         r->in.buffer = NULL;
22790                 }
22791                 if (r->in.buffer) {
22792                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22793                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22794                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22796                 }
22797                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22798                 NDR_PULL_ALLOC(ndr, r->out.needed);
22799                 ZERO_STRUCTP(r->out.needed);
22800                 NDR_PULL_ALLOC(ndr, r->out.count);
22801                 ZERO_STRUCTP(r->out.count);
22802         }
22803         if (flags & NDR_OUT) {
22804                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22805                 if (_ptr_info) {
22806                         NDR_PULL_ALLOC(ndr, r->out.info);
22807                 } else {
22808                         r->out.info = NULL;
22809                 }
22810                 if (r->out.info) {
22811                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22812                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22813                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22814                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22815                 }
22816                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22817                         NDR_PULL_ALLOC(ndr, r->out.needed);
22818                 }
22819                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22820                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22822                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22823                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22824                         NDR_PULL_ALLOC(ndr, r->out.count);
22825                 }
22826                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22827                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22829                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22830                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22831         }
22832         return NDR_ERR_SUCCESS;
22833 }
22834
22835 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22836 {
22837         uint32_t cntr_info_0;
22838         if (flags & NDR_IN) {
22839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22841         }
22842         if (flags & NDR_OUT) {
22843                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22844                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22845                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22846                 }
22847                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22848                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22849                 }
22850         }
22851         return NDR_ERR_SUCCESS;
22852 }
22853
22854 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22855 {
22856         uint32_t cntr_info_0;
22857         TALLOC_CTX *_mem_save_info_0;
22858         if (flags & NDR_IN) {
22859                 ZERO_STRUCT(r->out);
22860
22861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22863         }
22864         if (flags & NDR_OUT) {
22865                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22866                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22867                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22868                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22869                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22870                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22871                 }
22872                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22873                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22874                 }
22875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22876         }
22877         return NDR_ERR_SUCCESS;
22878 }
22879
22880 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22881 {
22882         uint32_t cntr_info_2;
22883         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22884         ndr->depth++;
22885         if (flags & NDR_SET_VALUES) {
22886                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22887         }
22888         if (flags & NDR_IN) {
22889                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22890                 ndr->depth++;
22891                 ndr_print_ptr(ndr, "handle", r->in.handle);
22892                 ndr->depth++;
22893                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22894                 ndr->depth--;
22895                 ndr_print_uint32(ndr, "level", r->in.level);
22896                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22897                 ndr->depth++;
22898                 if (r->in.buffer) {
22899                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22900                 }
22901                 ndr->depth--;
22902                 ndr_print_uint32(ndr, "offered", r->in.offered);
22903                 ndr->depth--;
22904         }
22905         if (flags & NDR_OUT) {
22906                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22907                 ndr->depth++;
22908                 ndr_print_ptr(ndr, "count", r->out.count);
22909                 ndr->depth++;
22910                 ndr_print_uint32(ndr, "count", *r->out.count);
22911                 ndr->depth--;
22912                 ndr_print_ptr(ndr, "info", r->out.info);
22913                 ndr->depth++;
22914                 ndr_print_ptr(ndr, "info", *r->out.info);
22915                 ndr->depth++;
22916                 if (*r->out.info) {
22917                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22918                         ndr->depth++;
22919                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22920                                 char *idx_2=NULL;
22921                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22922                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22923                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22924                                         free(idx_2);
22925                                 }
22926                         }
22927                         ndr->depth--;
22928                 }
22929                 ndr->depth--;
22930                 ndr->depth--;
22931                 ndr_print_ptr(ndr, "needed", r->out.needed);
22932                 ndr->depth++;
22933                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22934                 ndr->depth--;
22935                 ndr_print_WERROR(ndr, "result", r->out.result);
22936                 ndr->depth--;
22937         }
22938         ndr->depth--;
22939 }
22940
22941 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22942 {
22943         if (flags & NDR_IN) {
22944                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22945                 if (r->in.servername) {
22946                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22949                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22950                 }
22951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22952                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22953                 if (r->in.buffer) {
22954                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22955                 }
22956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22957         }
22958         if (flags & NDR_OUT) {
22959                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22960                 if (r->out.info) {
22961                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22962                 }
22963                 if (r->out.needed == NULL) {
22964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22965                 }
22966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22967                 if (r->out.count == NULL) {
22968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22969                 }
22970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22972         }
22973         return NDR_ERR_SUCCESS;
22974 }
22975
22976 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22977 {
22978         uint32_t _ptr_servername;
22979         uint32_t _ptr_buffer;
22980         uint32_t _ptr_info;
22981         TALLOC_CTX *_mem_save_servername_0;
22982         TALLOC_CTX *_mem_save_buffer_0;
22983         TALLOC_CTX *_mem_save_info_0;
22984         TALLOC_CTX *_mem_save_needed_0;
22985         TALLOC_CTX *_mem_save_count_0;
22986         if (flags & NDR_IN) {
22987                 ZERO_STRUCT(r->out);
22988
22989                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22990                 if (_ptr_servername) {
22991                         NDR_PULL_ALLOC(ndr, r->in.servername);
22992                 } else {
22993                         r->in.servername = NULL;
22994                 }
22995                 if (r->in.servername) {
22996                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22997                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22998                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22999                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23000                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23001                                 return 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));
23002                         }
23003                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23004                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23005                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23006                 }
23007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23008                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23009                 if (_ptr_buffer) {
23010                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23011                 } else {
23012                         r->in.buffer = NULL;
23013                 }
23014                 if (r->in.buffer) {
23015                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23016                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23017                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23018                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23019                 }
23020                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23021                 NDR_PULL_ALLOC(ndr, r->out.needed);
23022                 ZERO_STRUCTP(r->out.needed);
23023                 NDR_PULL_ALLOC(ndr, r->out.count);
23024                 ZERO_STRUCTP(r->out.count);
23025         }
23026         if (flags & NDR_OUT) {
23027                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23028                 if (_ptr_info) {
23029                         NDR_PULL_ALLOC(ndr, r->out.info);
23030                 } else {
23031                         r->out.info = NULL;
23032                 }
23033                 if (r->out.info) {
23034                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23035                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23036                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23037                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23038                 }
23039                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23040                         NDR_PULL_ALLOC(ndr, r->out.needed);
23041                 }
23042                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23043                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23044                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23045                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23046                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23047                         NDR_PULL_ALLOC(ndr, r->out.count);
23048                 }
23049                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23050                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23051                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23052                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23053                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23054         }
23055         return NDR_ERR_SUCCESS;
23056 }
23057
23058 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
23059 {
23060         uint32_t cntr_info_0;
23061         if (flags & NDR_IN) {
23062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23064         }
23065         if (flags & NDR_OUT) {
23066                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23067                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23068                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23069                 }
23070                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23071                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23072                 }
23073         }
23074         return NDR_ERR_SUCCESS;
23075 }
23076
23077 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
23078 {
23079         uint32_t cntr_info_0;
23080         TALLOC_CTX *_mem_save_info_0;
23081         if (flags & NDR_IN) {
23082                 ZERO_STRUCT(r->out);
23083
23084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23085                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23086         }
23087         if (flags & NDR_OUT) {
23088                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23089                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23090                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23091                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23092                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23093                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23094                 }
23095                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23096                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23097                 }
23098                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23099         }
23100         return NDR_ERR_SUCCESS;
23101 }
23102
23103 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
23104 {
23105         uint32_t cntr_info_2;
23106         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
23107         ndr->depth++;
23108         if (flags & NDR_SET_VALUES) {
23109                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23110         }
23111         if (flags & NDR_IN) {
23112                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
23113                 ndr->depth++;
23114                 ndr_print_ptr(ndr, "servername", r->in.servername);
23115                 ndr->depth++;
23116                 if (r->in.servername) {
23117                         ndr_print_string(ndr, "servername", r->in.servername);
23118                 }
23119                 ndr->depth--;
23120                 ndr_print_uint32(ndr, "level", r->in.level);
23121                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23122                 ndr->depth++;
23123                 if (r->in.buffer) {
23124                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23125                 }
23126                 ndr->depth--;
23127                 ndr_print_uint32(ndr, "offered", r->in.offered);
23128                 ndr->depth--;
23129         }
23130         if (flags & NDR_OUT) {
23131                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
23132                 ndr->depth++;
23133                 ndr_print_ptr(ndr, "count", r->out.count);
23134                 ndr->depth++;
23135                 ndr_print_uint32(ndr, "count", *r->out.count);
23136                 ndr->depth--;
23137                 ndr_print_ptr(ndr, "info", r->out.info);
23138                 ndr->depth++;
23139                 ndr_print_ptr(ndr, "info", *r->out.info);
23140                 ndr->depth++;
23141                 if (*r->out.info) {
23142                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23143                         ndr->depth++;
23144                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23145                                 char *idx_2=NULL;
23146                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23147                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23148                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23149                                         free(idx_2);
23150                                 }
23151                         }
23152                         ndr->depth--;
23153                 }
23154                 ndr->depth--;
23155                 ndr->depth--;
23156                 ndr_print_ptr(ndr, "needed", r->out.needed);
23157                 ndr->depth++;
23158                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23159                 ndr->depth--;
23160                 ndr_print_WERROR(ndr, "result", r->out.result);
23161                 ndr->depth--;
23162         }
23163         ndr->depth--;
23164 }
23165
23166 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
23167 {
23168         if (flags & NDR_IN) {
23169                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23170                 if (r->in.servername) {
23171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23174                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23175                 }
23176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23177                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23178                 if (r->in.buffer) {
23179                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23180                 }
23181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23182         }
23183         if (flags & NDR_OUT) {
23184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23185                 if (r->out.info) {
23186                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23187                 }
23188                 if (r->out.needed == NULL) {
23189                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23190                 }
23191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23192                 if (r->out.count == NULL) {
23193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23194                 }
23195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23196                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23197         }
23198         return NDR_ERR_SUCCESS;
23199 }
23200
23201 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
23202 {
23203         uint32_t _ptr_servername;
23204         uint32_t _ptr_buffer;
23205         uint32_t _ptr_info;
23206         TALLOC_CTX *_mem_save_servername_0;
23207         TALLOC_CTX *_mem_save_buffer_0;
23208         TALLOC_CTX *_mem_save_info_0;
23209         TALLOC_CTX *_mem_save_needed_0;
23210         TALLOC_CTX *_mem_save_count_0;
23211         if (flags & NDR_IN) {
23212                 ZERO_STRUCT(r->out);
23213
23214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23215                 if (_ptr_servername) {
23216                         NDR_PULL_ALLOC(ndr, r->in.servername);
23217                 } else {
23218                         r->in.servername = NULL;
23219                 }
23220                 if (r->in.servername) {
23221                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23222                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23223                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23224                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23225                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23226                                 return 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));
23227                         }
23228                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23229                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23231                 }
23232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23234                 if (_ptr_buffer) {
23235                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23236                 } else {
23237                         r->in.buffer = NULL;
23238                 }
23239                 if (r->in.buffer) {
23240                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23241                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23242                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23244                 }
23245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23246                 NDR_PULL_ALLOC(ndr, r->out.needed);
23247                 ZERO_STRUCTP(r->out.needed);
23248                 NDR_PULL_ALLOC(ndr, r->out.count);
23249                 ZERO_STRUCTP(r->out.count);
23250         }
23251         if (flags & NDR_OUT) {
23252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23253                 if (_ptr_info) {
23254                         NDR_PULL_ALLOC(ndr, r->out.info);
23255                 } else {
23256                         r->out.info = NULL;
23257                 }
23258                 if (r->out.info) {
23259                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23260                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23261                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23263                 }
23264                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23265                         NDR_PULL_ALLOC(ndr, r->out.needed);
23266                 }
23267                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23268                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23270                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23272                         NDR_PULL_ALLOC(ndr, r->out.count);
23273                 }
23274                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23275                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23279         }
23280         return NDR_ERR_SUCCESS;
23281 }
23282
23283 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
23284 {
23285         uint32_t cntr_info_0;
23286         if (flags & NDR_IN) {
23287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23289         }
23290         if (flags & NDR_OUT) {
23291                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23292                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23293                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23294                 }
23295                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23296                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23297                 }
23298         }
23299         return NDR_ERR_SUCCESS;
23300 }
23301
23302 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
23303 {
23304         uint32_t cntr_info_0;
23305         TALLOC_CTX *_mem_save_info_0;
23306         if (flags & NDR_IN) {
23307                 ZERO_STRUCT(r->out);
23308
23309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23311         }
23312         if (flags & NDR_OUT) {
23313                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23314                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23315                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23316                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23317                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23318                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23319                 }
23320                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23321                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23322                 }
23323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23324         }
23325         return NDR_ERR_SUCCESS;
23326 }
23327
23328 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
23329 {
23330         uint32_t cntr_info_2;
23331         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
23332         ndr->depth++;
23333         if (flags & NDR_SET_VALUES) {
23334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23335         }
23336         if (flags & NDR_IN) {
23337                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
23338                 ndr->depth++;
23339                 ndr_print_ptr(ndr, "servername", r->in.servername);
23340                 ndr->depth++;
23341                 if (r->in.servername) {
23342                         ndr_print_string(ndr, "servername", r->in.servername);
23343                 }
23344                 ndr->depth--;
23345                 ndr_print_uint32(ndr, "level", r->in.level);
23346                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23347                 ndr->depth++;
23348                 if (r->in.buffer) {
23349                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23350                 }
23351                 ndr->depth--;
23352                 ndr_print_uint32(ndr, "offered", r->in.offered);
23353                 ndr->depth--;
23354         }
23355         if (flags & NDR_OUT) {
23356                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
23357                 ndr->depth++;
23358                 ndr_print_ptr(ndr, "count", r->out.count);
23359                 ndr->depth++;
23360                 ndr_print_uint32(ndr, "count", *r->out.count);
23361                 ndr->depth--;
23362                 ndr_print_ptr(ndr, "info", r->out.info);
23363                 ndr->depth++;
23364                 ndr_print_ptr(ndr, "info", *r->out.info);
23365                 ndr->depth++;
23366                 if (*r->out.info) {
23367                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23368                         ndr->depth++;
23369                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23370                                 char *idx_2=NULL;
23371                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23372                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23373                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23374                                         free(idx_2);
23375                                 }
23376                         }
23377                         ndr->depth--;
23378                 }
23379                 ndr->depth--;
23380                 ndr->depth--;
23381                 ndr_print_ptr(ndr, "needed", r->out.needed);
23382                 ndr->depth++;
23383                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23384                 ndr->depth--;
23385                 ndr_print_WERROR(ndr, "result", r->out.result);
23386                 ndr->depth--;
23387         }
23388         ndr->depth--;
23389 }
23390
23391 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
23392 {
23393         if (flags & NDR_IN) {
23394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
23395                 if (r->in.server_name) {
23396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23398                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23399                         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));
23400                 }
23401                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
23402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23405                 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));
23406         }
23407         if (flags & NDR_OUT) {
23408                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23409         }
23410         return NDR_ERR_SUCCESS;
23411 }
23412
23413 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23414 {
23415         uint32_t _ptr_server_name;
23416         TALLOC_CTX *_mem_save_server_name_0;
23417         if (flags & NDR_IN) {
23418                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23419                 if (_ptr_server_name) {
23420                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23421                 } else {
23422                         r->in.server_name = NULL;
23423                 }
23424                 if (r->in.server_name) {
23425                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23426                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23428                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23429                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23430                                 return 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));
23431                         }
23432                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23433                         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));
23434                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23435                 }
23436                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23437                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23438                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23439                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23440                         return 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));
23441                 }
23442                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23443                 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));
23444         }
23445         if (flags & NDR_OUT) {
23446                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23447         }
23448         return NDR_ERR_SUCCESS;
23449 }
23450
23451 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23452 {
23453         ndr_print_struct(ndr, name, "spoolss_AddPort");
23454         ndr->depth++;
23455         if (flags & NDR_SET_VALUES) {
23456                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23457         }
23458         if (flags & NDR_IN) {
23459                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23460                 ndr->depth++;
23461                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23462                 ndr->depth++;
23463                 if (r->in.server_name) {
23464                         ndr_print_string(ndr, "server_name", r->in.server_name);
23465                 }
23466                 ndr->depth--;
23467                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23468                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23469                 ndr->depth--;
23470         }
23471         if (flags & NDR_OUT) {
23472                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23473                 ndr->depth++;
23474                 ndr_print_WERROR(ndr, "result", r->out.result);
23475                 ndr->depth--;
23476         }
23477         ndr->depth--;
23478 }
23479
23480 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23481 {
23482         if (flags & NDR_IN) {
23483         }
23484         if (flags & NDR_OUT) {
23485                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23486         }
23487         return NDR_ERR_SUCCESS;
23488 }
23489
23490 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23491 {
23492         if (flags & NDR_IN) {
23493         }
23494         if (flags & NDR_OUT) {
23495                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23496         }
23497         return NDR_ERR_SUCCESS;
23498 }
23499
23500 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23501 {
23502         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23503         ndr->depth++;
23504         if (flags & NDR_SET_VALUES) {
23505                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23506         }
23507         if (flags & NDR_IN) {
23508                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23509                 ndr->depth++;
23510                 ndr->depth--;
23511         }
23512         if (flags & NDR_OUT) {
23513                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23514                 ndr->depth++;
23515                 ndr_print_WERROR(ndr, "result", r->out.result);
23516                 ndr->depth--;
23517         }
23518         ndr->depth--;
23519 }
23520
23521 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23522 {
23523         if (flags & NDR_IN) {
23524         }
23525         if (flags & NDR_OUT) {
23526                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23527         }
23528         return NDR_ERR_SUCCESS;
23529 }
23530
23531 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23532 {
23533         if (flags & NDR_IN) {
23534         }
23535         if (flags & NDR_OUT) {
23536                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23537         }
23538         return NDR_ERR_SUCCESS;
23539 }
23540
23541 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23542 {
23543         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23544         ndr->depth++;
23545         if (flags & NDR_SET_VALUES) {
23546                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23547         }
23548         if (flags & NDR_IN) {
23549                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23550                 ndr->depth++;
23551                 ndr->depth--;
23552         }
23553         if (flags & NDR_OUT) {
23554                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23555                 ndr->depth++;
23556                 ndr_print_WERROR(ndr, "result", r->out.result);
23557                 ndr->depth--;
23558         }
23559         ndr->depth--;
23560 }
23561
23562 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23563 {
23564         if (flags & NDR_IN) {
23565         }
23566         if (flags & NDR_OUT) {
23567                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23568         }
23569         return NDR_ERR_SUCCESS;
23570 }
23571
23572 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23573 {
23574         if (flags & NDR_IN) {
23575         }
23576         if (flags & NDR_OUT) {
23577                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23578         }
23579         return NDR_ERR_SUCCESS;
23580 }
23581
23582 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23583 {
23584         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23585         ndr->depth++;
23586         if (flags & NDR_SET_VALUES) {
23587                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23588         }
23589         if (flags & NDR_IN) {
23590                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23591                 ndr->depth++;
23592                 ndr->depth--;
23593         }
23594         if (flags & NDR_OUT) {
23595                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23596                 ndr->depth++;
23597                 ndr_print_WERROR(ndr, "result", r->out.result);
23598                 ndr->depth--;
23599         }
23600         ndr->depth--;
23601 }
23602
23603 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23604 {
23605         if (flags & NDR_IN) {
23606         }
23607         if (flags & NDR_OUT) {
23608                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23609         }
23610         return NDR_ERR_SUCCESS;
23611 }
23612
23613 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23614 {
23615         if (flags & NDR_IN) {
23616         }
23617         if (flags & NDR_OUT) {
23618                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23619         }
23620         return NDR_ERR_SUCCESS;
23621 }
23622
23623 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23624 {
23625         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23626         ndr->depth++;
23627         if (flags & NDR_SET_VALUES) {
23628                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23629         }
23630         if (flags & NDR_IN) {
23631                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23632                 ndr->depth++;
23633                 ndr->depth--;
23634         }
23635         if (flags & NDR_OUT) {
23636                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23637                 ndr->depth++;
23638                 ndr_print_WERROR(ndr, "result", r->out.result);
23639                 ndr->depth--;
23640         }
23641         ndr->depth--;
23642 }
23643
23644 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23645 {
23646         if (flags & NDR_IN) {
23647         }
23648         if (flags & NDR_OUT) {
23649                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23650         }
23651         return NDR_ERR_SUCCESS;
23652 }
23653
23654 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23655 {
23656         if (flags & NDR_IN) {
23657         }
23658         if (flags & NDR_OUT) {
23659                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23660         }
23661         return NDR_ERR_SUCCESS;
23662 }
23663
23664 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23665 {
23666         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23667         ndr->depth++;
23668         if (flags & NDR_SET_VALUES) {
23669                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23670         }
23671         if (flags & NDR_IN) {
23672                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23673                 ndr->depth++;
23674                 ndr->depth--;
23675         }
23676         if (flags & NDR_OUT) {
23677                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23678                 ndr->depth++;
23679                 ndr_print_WERROR(ndr, "result", r->out.result);
23680                 ndr->depth--;
23681         }
23682         ndr->depth--;
23683 }
23684
23685 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23686 {
23687         if (flags & NDR_IN) {
23688         }
23689         if (flags & NDR_OUT) {
23690                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23691         }
23692         return NDR_ERR_SUCCESS;
23693 }
23694
23695 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23696 {
23697         if (flags & NDR_IN) {
23698         }
23699         if (flags & NDR_OUT) {
23700                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23701         }
23702         return NDR_ERR_SUCCESS;
23703 }
23704
23705 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23706 {
23707         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23708         ndr->depth++;
23709         if (flags & NDR_SET_VALUES) {
23710                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23711         }
23712         if (flags & NDR_IN) {
23713                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23714                 ndr->depth++;
23715                 ndr->depth--;
23716         }
23717         if (flags & NDR_OUT) {
23718                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23719                 ndr->depth++;
23720                 ndr_print_WERROR(ndr, "result", r->out.result);
23721                 ndr->depth--;
23722         }
23723         ndr->depth--;
23724 }
23725
23726 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23727 {
23728         if (flags & NDR_IN) {
23729         }
23730         if (flags & NDR_OUT) {
23731                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23732         }
23733         return NDR_ERR_SUCCESS;
23734 }
23735
23736 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23737 {
23738         if (flags & NDR_IN) {
23739         }
23740         if (flags & NDR_OUT) {
23741                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23742         }
23743         return NDR_ERR_SUCCESS;
23744 }
23745
23746 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23747 {
23748         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23749         ndr->depth++;
23750         if (flags & NDR_SET_VALUES) {
23751                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23752         }
23753         if (flags & NDR_IN) {
23754                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23755                 ndr->depth++;
23756                 ndr->depth--;
23757         }
23758         if (flags & NDR_OUT) {
23759                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23760                 ndr->depth++;
23761                 ndr_print_WERROR(ndr, "result", r->out.result);
23762                 ndr->depth--;
23763         }
23764         ndr->depth--;
23765 }
23766
23767 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23768 {
23769         if (flags & NDR_IN) {
23770         }
23771         if (flags & NDR_OUT) {
23772                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23773         }
23774         return NDR_ERR_SUCCESS;
23775 }
23776
23777 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23778 {
23779         if (flags & NDR_IN) {
23780         }
23781         if (flags & NDR_OUT) {
23782                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23783         }
23784         return NDR_ERR_SUCCESS;
23785 }
23786
23787 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23788 {
23789         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23790         ndr->depth++;
23791         if (flags & NDR_SET_VALUES) {
23792                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23793         }
23794         if (flags & NDR_IN) {
23795                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23796                 ndr->depth++;
23797                 ndr->depth--;
23798         }
23799         if (flags & NDR_OUT) {
23800                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23801                 ndr->depth++;
23802                 ndr_print_WERROR(ndr, "result", r->out.result);
23803                 ndr->depth--;
23804         }
23805         ndr->depth--;
23806 }
23807
23808 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23809 {
23810         if (flags & NDR_IN) {
23811         }
23812         if (flags & NDR_OUT) {
23813                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23814         }
23815         return NDR_ERR_SUCCESS;
23816 }
23817
23818 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23819 {
23820         if (flags & NDR_IN) {
23821         }
23822         if (flags & NDR_OUT) {
23823                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23824         }
23825         return NDR_ERR_SUCCESS;
23826 }
23827
23828 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23829 {
23830         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23831         ndr->depth++;
23832         if (flags & NDR_SET_VALUES) {
23833                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23834         }
23835         if (flags & NDR_IN) {
23836                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23837                 ndr->depth++;
23838                 ndr->depth--;
23839         }
23840         if (flags & NDR_OUT) {
23841                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23842                 ndr->depth++;
23843                 ndr_print_WERROR(ndr, "result", r->out.result);
23844                 ndr->depth--;
23845         }
23846         ndr->depth--;
23847 }
23848
23849 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23850 {
23851         if (flags & NDR_IN) {
23852         }
23853         if (flags & NDR_OUT) {
23854                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23855         }
23856         return NDR_ERR_SUCCESS;
23857 }
23858
23859 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23860 {
23861         if (flags & NDR_IN) {
23862         }
23863         if (flags & NDR_OUT) {
23864                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23865         }
23866         return NDR_ERR_SUCCESS;
23867 }
23868
23869 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23870 {
23871         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23872         ndr->depth++;
23873         if (flags & NDR_SET_VALUES) {
23874                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23875         }
23876         if (flags & NDR_IN) {
23877                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23878                 ndr->depth++;
23879                 ndr->depth--;
23880         }
23881         if (flags & NDR_OUT) {
23882                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23883                 ndr->depth++;
23884                 ndr_print_WERROR(ndr, "result", r->out.result);
23885                 ndr->depth--;
23886         }
23887         ndr->depth--;
23888 }
23889
23890 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23891 {
23892         if (flags & NDR_IN) {
23893         }
23894         if (flags & NDR_OUT) {
23895                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23896         }
23897         return NDR_ERR_SUCCESS;
23898 }
23899
23900 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23901 {
23902         if (flags & NDR_IN) {
23903         }
23904         if (flags & NDR_OUT) {
23905                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23906         }
23907         return NDR_ERR_SUCCESS;
23908 }
23909
23910 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23911 {
23912         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23913         ndr->depth++;
23914         if (flags & NDR_SET_VALUES) {
23915                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23916         }
23917         if (flags & NDR_IN) {
23918                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23919                 ndr->depth++;
23920                 ndr->depth--;
23921         }
23922         if (flags & NDR_OUT) {
23923                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23924                 ndr->depth++;
23925                 ndr_print_WERROR(ndr, "result", r->out.result);
23926                 ndr->depth--;
23927         }
23928         ndr->depth--;
23929 }
23930
23931 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23932 {
23933         if (flags & NDR_IN) {
23934         }
23935         if (flags & NDR_OUT) {
23936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23937         }
23938         return NDR_ERR_SUCCESS;
23939 }
23940
23941 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23942 {
23943         if (flags & NDR_IN) {
23944         }
23945         if (flags & NDR_OUT) {
23946                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23947         }
23948         return NDR_ERR_SUCCESS;
23949 }
23950
23951 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23952 {
23953         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23954         ndr->depth++;
23955         if (flags & NDR_SET_VALUES) {
23956                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23957         }
23958         if (flags & NDR_IN) {
23959                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23960                 ndr->depth++;
23961                 ndr->depth--;
23962         }
23963         if (flags & NDR_OUT) {
23964                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23965                 ndr->depth++;
23966                 ndr_print_WERROR(ndr, "result", r->out.result);
23967                 ndr->depth--;
23968         }
23969         ndr->depth--;
23970 }
23971
23972 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23973 {
23974         if (flags & NDR_IN) {
23975         }
23976         if (flags & NDR_OUT) {
23977                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23978         }
23979         return NDR_ERR_SUCCESS;
23980 }
23981
23982 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23983 {
23984         if (flags & NDR_IN) {
23985         }
23986         if (flags & NDR_OUT) {
23987                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23988         }
23989         return NDR_ERR_SUCCESS;
23990 }
23991
23992 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23993 {
23994         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23995         ndr->depth++;
23996         if (flags & NDR_SET_VALUES) {
23997                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23998         }
23999         if (flags & NDR_IN) {
24000                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
24001                 ndr->depth++;
24002                 ndr->depth--;
24003         }
24004         if (flags & NDR_OUT) {
24005                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
24006                 ndr->depth++;
24007                 ndr_print_WERROR(ndr, "result", r->out.result);
24008                 ndr->depth--;
24009         }
24010         ndr->depth--;
24011 }
24012
24013 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
24014 {
24015         if (flags & NDR_IN) {
24016                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24017                 if (r->in.servername) {
24018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24020                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24021                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24022                 }
24023                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
24024                 if (r->in.print_processor_name) {
24025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24028                         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));
24029                 }
24030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24031                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24032                 if (r->in.buffer) {
24033                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24034                 }
24035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24036         }
24037         if (flags & NDR_OUT) {
24038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24039                 if (r->out.info) {
24040                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24041                 }
24042                 if (r->out.needed == NULL) {
24043                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24044                 }
24045                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24046                 if (r->out.count == NULL) {
24047                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24048                 }
24049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24050                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24051         }
24052         return NDR_ERR_SUCCESS;
24053 }
24054
24055 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
24056 {
24057         uint32_t _ptr_servername;
24058         uint32_t _ptr_print_processor_name;
24059         uint32_t _ptr_buffer;
24060         uint32_t _ptr_info;
24061         TALLOC_CTX *_mem_save_servername_0;
24062         TALLOC_CTX *_mem_save_print_processor_name_0;
24063         TALLOC_CTX *_mem_save_buffer_0;
24064         TALLOC_CTX *_mem_save_info_0;
24065         TALLOC_CTX *_mem_save_needed_0;
24066         TALLOC_CTX *_mem_save_count_0;
24067         if (flags & NDR_IN) {
24068                 ZERO_STRUCT(r->out);
24069
24070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24071                 if (_ptr_servername) {
24072                         NDR_PULL_ALLOC(ndr, r->in.servername);
24073                 } else {
24074                         r->in.servername = NULL;
24075                 }
24076                 if (r->in.servername) {
24077                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24078                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24081                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24082                                 return 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));
24083                         }
24084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24087                 }
24088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
24089                 if (_ptr_print_processor_name) {
24090                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
24091                 } else {
24092                         r->in.print_processor_name = NULL;
24093                 }
24094                 if (r->in.print_processor_name) {
24095                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24096                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
24097                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
24098                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
24099                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
24100                                 return 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));
24101                         }
24102                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
24103                         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));
24104                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
24105                 }
24106                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24107                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24108                 if (_ptr_buffer) {
24109                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24110                 } else {
24111                         r->in.buffer = NULL;
24112                 }
24113                 if (r->in.buffer) {
24114                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24115                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24116                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24117                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24118                 }
24119                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24120                 NDR_PULL_ALLOC(ndr, r->out.needed);
24121                 ZERO_STRUCTP(r->out.needed);
24122                 NDR_PULL_ALLOC(ndr, r->out.count);
24123                 ZERO_STRUCTP(r->out.count);
24124         }
24125         if (flags & NDR_OUT) {
24126                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24127                 if (_ptr_info) {
24128                         NDR_PULL_ALLOC(ndr, r->out.info);
24129                 } else {
24130                         r->out.info = NULL;
24131                 }
24132                 if (r->out.info) {
24133                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24134                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24135                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24136                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24137                 }
24138                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24139                         NDR_PULL_ALLOC(ndr, r->out.needed);
24140                 }
24141                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24142                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24144                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24146                         NDR_PULL_ALLOC(ndr, r->out.count);
24147                 }
24148                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24149                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24152                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24153         }
24154         return NDR_ERR_SUCCESS;
24155 }
24156
24157 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
24158 {
24159         uint32_t cntr_info_0;
24160         if (flags & NDR_IN) {
24161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24163         }
24164         if (flags & NDR_OUT) {
24165                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24166                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24167                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24168                 }
24169                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24170                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24171                 }
24172         }
24173         return NDR_ERR_SUCCESS;
24174 }
24175
24176 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
24177 {
24178         uint32_t cntr_info_0;
24179         TALLOC_CTX *_mem_save_info_0;
24180         if (flags & NDR_IN) {
24181                 ZERO_STRUCT(r->out);
24182
24183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24185         }
24186         if (flags & NDR_OUT) {
24187                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24188                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24189                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24190                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24191                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24192                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24193                 }
24194                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24195                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24196                 }
24197                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24198         }
24199         return NDR_ERR_SUCCESS;
24200 }
24201
24202 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
24203 {
24204         uint32_t cntr_info_2;
24205         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
24206         ndr->depth++;
24207         if (flags & NDR_SET_VALUES) {
24208                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24209         }
24210         if (flags & NDR_IN) {
24211                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
24212                 ndr->depth++;
24213                 ndr_print_ptr(ndr, "servername", r->in.servername);
24214                 ndr->depth++;
24215                 if (r->in.servername) {
24216                         ndr_print_string(ndr, "servername", r->in.servername);
24217                 }
24218                 ndr->depth--;
24219                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
24220                 ndr->depth++;
24221                 if (r->in.print_processor_name) {
24222                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
24223                 }
24224                 ndr->depth--;
24225                 ndr_print_uint32(ndr, "level", r->in.level);
24226                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24227                 ndr->depth++;
24228                 if (r->in.buffer) {
24229                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24230                 }
24231                 ndr->depth--;
24232                 ndr_print_uint32(ndr, "offered", r->in.offered);
24233                 ndr->depth--;
24234         }
24235         if (flags & NDR_OUT) {
24236                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
24237                 ndr->depth++;
24238                 ndr_print_ptr(ndr, "count", r->out.count);
24239                 ndr->depth++;
24240                 ndr_print_uint32(ndr, "count", *r->out.count);
24241                 ndr->depth--;
24242                 ndr_print_ptr(ndr, "info", r->out.info);
24243                 ndr->depth++;
24244                 ndr_print_ptr(ndr, "info", *r->out.info);
24245                 ndr->depth++;
24246                 if (*r->out.info) {
24247                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24248                         ndr->depth++;
24249                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24250                                 char *idx_2=NULL;
24251                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24252                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24253                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24254                                         free(idx_2);
24255                                 }
24256                         }
24257                         ndr->depth--;
24258                 }
24259                 ndr->depth--;
24260                 ndr->depth--;
24261                 ndr_print_ptr(ndr, "needed", r->out.needed);
24262                 ndr->depth++;
24263                 ndr_print_uint32(ndr, "needed", *r->out.needed);
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_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
24272 {
24273         if (flags & NDR_IN) {
24274                 if (r->in.handle == NULL) {
24275                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24276                 }
24277                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24278                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
24279                 if (r->in.data_type) {
24280                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24281                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24282                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24283                         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));
24284                 }
24285                 if (r->in.devmode_ctr == NULL) {
24286                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24287                 }
24288                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24289         }
24290         if (flags & NDR_OUT) {
24291                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24292         }
24293         return NDR_ERR_SUCCESS;
24294 }
24295
24296 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
24297 {
24298         uint32_t _ptr_data_type;
24299         TALLOC_CTX *_mem_save_handle_0;
24300         TALLOC_CTX *_mem_save_data_type_0;
24301         TALLOC_CTX *_mem_save_devmode_ctr_0;
24302         if (flags & NDR_IN) {
24303                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24304                         NDR_PULL_ALLOC(ndr, r->in.handle);
24305                 }
24306                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24307                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24308                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24309                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24310                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
24311                 if (_ptr_data_type) {
24312                         NDR_PULL_ALLOC(ndr, r->in.data_type);
24313                 } else {
24314                         r->in.data_type = NULL;
24315                 }
24316                 if (r->in.data_type) {
24317                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24318                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
24319                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
24320                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
24321                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
24322                                 return 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));
24323                         }
24324                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
24325                         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));
24326                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
24327                 }
24328                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24329                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24330                 }
24331                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24332                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24333                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24334                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24335         }
24336         if (flags & NDR_OUT) {
24337                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24338         }
24339         return NDR_ERR_SUCCESS;
24340 }
24341
24342 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
24343 {
24344         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
24345         ndr->depth++;
24346         if (flags & NDR_SET_VALUES) {
24347                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24348         }
24349         if (flags & NDR_IN) {
24350                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
24351                 ndr->depth++;
24352                 ndr_print_ptr(ndr, "handle", r->in.handle);
24353                 ndr->depth++;
24354                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24355                 ndr->depth--;
24356                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
24357                 ndr->depth++;
24358                 if (r->in.data_type) {
24359                         ndr_print_string(ndr, "data_type", r->in.data_type);
24360                 }
24361                 ndr->depth--;
24362                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24363                 ndr->depth++;
24364                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24365                 ndr->depth--;
24366                 ndr->depth--;
24367         }
24368         if (flags & NDR_OUT) {
24369                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
24370                 ndr->depth++;
24371                 ndr_print_WERROR(ndr, "result", r->out.result);
24372                 ndr->depth--;
24373         }
24374         ndr->depth--;
24375 }
24376
24377 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
24378 {
24379         if (flags & NDR_IN) {
24380                 if (r->in.handle == NULL) {
24381                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24382                 }
24383                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
24385                 if (r->in.architecture) {
24386                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24387                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24388                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24389                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24390                 }
24391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24393                 if (r->in.buffer) {
24394                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24395                 }
24396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
24398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
24399         }
24400         if (flags & NDR_OUT) {
24401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24402                 if (r->out.info) {
24403                         {
24404                                 struct ndr_push *_ndr_info;
24405                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24406                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24407                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24408                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24409                         }
24410                 }
24411                 if (r->out.needed == NULL) {
24412                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24413                 }
24414                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24415                 if (r->out.server_major_version == NULL) {
24416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24417                 }
24418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24419                 if (r->out.server_minor_version == NULL) {
24420                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24421                 }
24422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24423                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24424         }
24425         return NDR_ERR_SUCCESS;
24426 }
24427
24428 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24429 {
24430         uint32_t _ptr_architecture;
24431         uint32_t _ptr_buffer;
24432         uint32_t _ptr_info;
24433         TALLOC_CTX *_mem_save_handle_0;
24434         TALLOC_CTX *_mem_save_architecture_0;
24435         TALLOC_CTX *_mem_save_buffer_0;
24436         TALLOC_CTX *_mem_save_info_0;
24437         TALLOC_CTX *_mem_save_needed_0;
24438         TALLOC_CTX *_mem_save_server_major_version_0;
24439         TALLOC_CTX *_mem_save_server_minor_version_0;
24440         if (flags & NDR_IN) {
24441                 ZERO_STRUCT(r->out);
24442
24443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24444                         NDR_PULL_ALLOC(ndr, r->in.handle);
24445                 }
24446                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24447                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24448                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24450                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24451                 if (_ptr_architecture) {
24452                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24453                 } else {
24454                         r->in.architecture = NULL;
24455                 }
24456                 if (r->in.architecture) {
24457                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24458                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24459                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24460                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24461                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24462                                 return 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));
24463                         }
24464                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24465                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24466                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24467                 }
24468                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24469                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24470                 if (_ptr_buffer) {
24471                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24472                 } else {
24473                         r->in.buffer = NULL;
24474                 }
24475                 if (r->in.buffer) {
24476                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24477                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24478                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24479                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24480                 }
24481                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24482                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24483                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24484                 NDR_PULL_ALLOC(ndr, r->out.needed);
24485                 ZERO_STRUCTP(r->out.needed);
24486                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24487                 ZERO_STRUCTP(r->out.server_major_version);
24488                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24489                 ZERO_STRUCTP(r->out.server_minor_version);
24490         }
24491         if (flags & NDR_OUT) {
24492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24493                 if (_ptr_info) {
24494                         NDR_PULL_ALLOC(ndr, r->out.info);
24495                 } else {
24496                         r->out.info = NULL;
24497                 }
24498                 if (r->out.info) {
24499                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24500                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24501                         {
24502                                 struct ndr_pull *_ndr_info;
24503                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24504                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24505                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24506                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24507                         }
24508                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24509                 }
24510                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24511                         NDR_PULL_ALLOC(ndr, r->out.needed);
24512                 }
24513                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24514                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24516                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24517                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24518                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24519                 }
24520                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24521                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24522                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24523                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24524                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24525                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24526                 }
24527                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24528                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24530                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24531                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24532         }
24533         return NDR_ERR_SUCCESS;
24534 }
24535
24536 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24537 {
24538         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24539         ndr->depth++;
24540         if (flags & NDR_SET_VALUES) {
24541                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24542         }
24543         if (flags & NDR_IN) {
24544                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24545                 ndr->depth++;
24546                 ndr_print_ptr(ndr, "handle", r->in.handle);
24547                 ndr->depth++;
24548                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24549                 ndr->depth--;
24550                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24551                 ndr->depth++;
24552                 if (r->in.architecture) {
24553                         ndr_print_string(ndr, "architecture", r->in.architecture);
24554                 }
24555                 ndr->depth--;
24556                 ndr_print_uint32(ndr, "level", r->in.level);
24557                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24558                 ndr->depth++;
24559                 if (r->in.buffer) {
24560                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24561                 }
24562                 ndr->depth--;
24563                 ndr_print_uint32(ndr, "offered", r->in.offered);
24564                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24565                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24566                 ndr->depth--;
24567         }
24568         if (flags & NDR_OUT) {
24569                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24570                 ndr->depth++;
24571                 ndr_print_ptr(ndr, "info", r->out.info);
24572                 ndr->depth++;
24573                 if (r->out.info) {
24574                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24575                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24576                 }
24577                 ndr->depth--;
24578                 ndr_print_ptr(ndr, "needed", r->out.needed);
24579                 ndr->depth++;
24580                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24581                 ndr->depth--;
24582                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24583                 ndr->depth++;
24584                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24585                 ndr->depth--;
24586                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24587                 ndr->depth++;
24588                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24589                 ndr->depth--;
24590                 ndr_print_WERROR(ndr, "result", r->out.result);
24591                 ndr->depth--;
24592         }
24593         ndr->depth--;
24594 }
24595
24596 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24597 {
24598         if (flags & NDR_IN) {
24599         }
24600         if (flags & NDR_OUT) {
24601                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24602         }
24603         return NDR_ERR_SUCCESS;
24604 }
24605
24606 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24607 {
24608         if (flags & NDR_IN) {
24609         }
24610         if (flags & NDR_OUT) {
24611                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24612         }
24613         return NDR_ERR_SUCCESS;
24614 }
24615
24616 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24617 {
24618         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24619         ndr->depth++;
24620         if (flags & NDR_SET_VALUES) {
24621                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24622         }
24623         if (flags & NDR_IN) {
24624                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24625                 ndr->depth++;
24626                 ndr->depth--;
24627         }
24628         if (flags & NDR_OUT) {
24629                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24630                 ndr->depth++;
24631                 ndr_print_WERROR(ndr, "result", r->out.result);
24632                 ndr->depth--;
24633         }
24634         ndr->depth--;
24635 }
24636
24637 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24638 {
24639         if (flags & NDR_IN) {
24640         }
24641         if (flags & NDR_OUT) {
24642                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24643         }
24644         return NDR_ERR_SUCCESS;
24645 }
24646
24647 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24648 {
24649         if (flags & NDR_IN) {
24650         }
24651         if (flags & NDR_OUT) {
24652                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24653         }
24654         return NDR_ERR_SUCCESS;
24655 }
24656
24657 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24658 {
24659         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24660         ndr->depth++;
24661         if (flags & NDR_SET_VALUES) {
24662                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24663         }
24664         if (flags & NDR_IN) {
24665                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24666                 ndr->depth++;
24667                 ndr->depth--;
24668         }
24669         if (flags & NDR_OUT) {
24670                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24671                 ndr->depth++;
24672                 ndr_print_WERROR(ndr, "result", r->out.result);
24673                 ndr->depth--;
24674         }
24675         ndr->depth--;
24676 }
24677
24678 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24679 {
24680         if (flags & NDR_IN) {
24681                 if (r->in.handle == NULL) {
24682                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24683                 }
24684                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24685         }
24686         if (flags & NDR_OUT) {
24687                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24688         }
24689         return NDR_ERR_SUCCESS;
24690 }
24691
24692 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24693 {
24694         TALLOC_CTX *_mem_save_handle_0;
24695         if (flags & NDR_IN) {
24696                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24697                         NDR_PULL_ALLOC(ndr, r->in.handle);
24698                 }
24699                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24700                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24701                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24702                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24703         }
24704         if (flags & NDR_OUT) {
24705                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24706         }
24707         return NDR_ERR_SUCCESS;
24708 }
24709
24710 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24711 {
24712         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24713         ndr->depth++;
24714         if (flags & NDR_SET_VALUES) {
24715                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24716         }
24717         if (flags & NDR_IN) {
24718                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24719                 ndr->depth++;
24720                 ndr_print_ptr(ndr, "handle", r->in.handle);
24721                 ndr->depth++;
24722                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24723                 ndr->depth--;
24724                 ndr->depth--;
24725         }
24726         if (flags & NDR_OUT) {
24727                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24728                 ndr->depth++;
24729                 ndr_print_WERROR(ndr, "result", r->out.result);
24730                 ndr->depth--;
24731         }
24732         ndr->depth--;
24733 }
24734
24735 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24736 {
24737         if (flags & NDR_IN) {
24738         }
24739         if (flags & NDR_OUT) {
24740                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24741         }
24742         return NDR_ERR_SUCCESS;
24743 }
24744
24745 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24746 {
24747         if (flags & NDR_IN) {
24748         }
24749         if (flags & NDR_OUT) {
24750                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24751         }
24752         return NDR_ERR_SUCCESS;
24753 }
24754
24755 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24756 {
24757         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24758         ndr->depth++;
24759         if (flags & NDR_SET_VALUES) {
24760                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24761         }
24762         if (flags & NDR_IN) {
24763                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24764                 ndr->depth++;
24765                 ndr->depth--;
24766         }
24767         if (flags & NDR_OUT) {
24768                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24769                 ndr->depth++;
24770                 ndr_print_WERROR(ndr, "result", r->out.result);
24771                 ndr->depth--;
24772         }
24773         ndr->depth--;
24774 }
24775
24776 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24777 {
24778         if (flags & NDR_IN) {
24779                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24781                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24782                 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));
24783                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24784                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24785                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24786                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24787                 if (r->in.buffer) {
24788                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24789                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24790                 }
24791         }
24792         if (flags & NDR_OUT) {
24793                 if (r->out.handle == NULL) {
24794                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24795                 }
24796                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24797                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24798         }
24799         return NDR_ERR_SUCCESS;
24800 }
24801
24802 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24803 {
24804         uint32_t _ptr_buffer;
24805         TALLOC_CTX *_mem_save_buffer_0;
24806         TALLOC_CTX *_mem_save_handle_0;
24807         if (flags & NDR_IN) {
24808                 ZERO_STRUCT(r->out);
24809
24810                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24811                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24812                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24813                         return 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));
24814                 }
24815                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24816                 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));
24817                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24818                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24820                 if (r->in.bufsize > 512) {
24821                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24822                 }
24823                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24824                 if (_ptr_buffer) {
24825                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24826                 } else {
24827                         r->in.buffer = NULL;
24828                 }
24829                 if (r->in.buffer) {
24830                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24831                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24832                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24833                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24834                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24836                 }
24837                 NDR_PULL_ALLOC(ndr, r->out.handle);
24838                 ZERO_STRUCTP(r->out.handle);
24839                 if (r->in.buffer) {
24840                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24841                 }
24842         }
24843         if (flags & NDR_OUT) {
24844                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24845                         NDR_PULL_ALLOC(ndr, r->out.handle);
24846                 }
24847                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24848                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24849                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24850                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24851                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24852         }
24853         return NDR_ERR_SUCCESS;
24854 }
24855
24856 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24857 {
24858         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24859         ndr->depth++;
24860         if (flags & NDR_SET_VALUES) {
24861                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24862         }
24863         if (flags & NDR_IN) {
24864                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24865                 ndr->depth++;
24866                 ndr_print_string(ndr, "server_name", r->in.server_name);
24867                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24868                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24869                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24870                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24871                 ndr->depth++;
24872                 if (r->in.buffer) {
24873                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24874                 }
24875                 ndr->depth--;
24876                 ndr->depth--;
24877         }
24878         if (flags & NDR_OUT) {
24879                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24880                 ndr->depth++;
24881                 ndr_print_ptr(ndr, "handle", r->out.handle);
24882                 ndr->depth++;
24883                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24884                 ndr->depth--;
24885                 ndr_print_WERROR(ndr, "result", r->out.result);
24886                 ndr->depth--;
24887         }
24888         ndr->depth--;
24889 }
24890
24891 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24892 {
24893         if (flags & NDR_IN) {
24894                 if (r->in.handle == NULL) {
24895                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24896                 }
24897                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24898                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24901                 if (r->in.buffer) {
24902                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24903                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24904                 }
24905         }
24906         if (flags & NDR_OUT) {
24907                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24908         }
24909         return NDR_ERR_SUCCESS;
24910 }
24911
24912 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24913 {
24914         uint32_t _ptr_buffer;
24915         TALLOC_CTX *_mem_save_handle_0;
24916         TALLOC_CTX *_mem_save_buffer_0;
24917         if (flags & NDR_IN) {
24918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24919                         NDR_PULL_ALLOC(ndr, r->in.handle);
24920                 }
24921                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24922                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24923                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24924                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24925                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24926                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24927                 if (r->in.bufsize > 512) {
24928                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24929                 }
24930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24931                 if (_ptr_buffer) {
24932                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24933                 } else {
24934                         r->in.buffer = NULL;
24935                 }
24936                 if (r->in.buffer) {
24937                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24938                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24940                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24941                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24942                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24943                 }
24944                 if (r->in.buffer) {
24945                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24946                 }
24947         }
24948         if (flags & NDR_OUT) {
24949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24950         }
24951         return NDR_ERR_SUCCESS;
24952 }
24953
24954 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24955 {
24956         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24957         ndr->depth++;
24958         if (flags & NDR_SET_VALUES) {
24959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24960         }
24961         if (flags & NDR_IN) {
24962                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24963                 ndr->depth++;
24964                 ndr_print_ptr(ndr, "handle", r->in.handle);
24965                 ndr->depth++;
24966                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24967                 ndr->depth--;
24968                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24969                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24970                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24971                 ndr->depth++;
24972                 if (r->in.buffer) {
24973                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24974                 }
24975                 ndr->depth--;
24976                 ndr->depth--;
24977         }
24978         if (flags & NDR_OUT) {
24979                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24980                 ndr->depth++;
24981                 ndr_print_WERROR(ndr, "result", r->out.result);
24982                 ndr->depth--;
24983         }
24984         ndr->depth--;
24985 }
24986
24987 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24988 {
24989         if (flags & NDR_IN) {
24990                 if (r->in.handle == NULL) {
24991                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24992                 }
24993                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24994         }
24995         if (flags & NDR_OUT) {
24996                 if (r->out.handle == NULL) {
24997                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24998                 }
24999                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25000                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25001         }
25002         return NDR_ERR_SUCCESS;
25003 }
25004
25005 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
25006 {
25007         TALLOC_CTX *_mem_save_handle_0;
25008         if (flags & NDR_IN) {
25009                 ZERO_STRUCT(r->out);
25010
25011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25012                         NDR_PULL_ALLOC(ndr, r->in.handle);
25013                 }
25014                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25015                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25016                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25018                 NDR_PULL_ALLOC(ndr, r->out.handle);
25019                 *r->out.handle = *r->in.handle;
25020         }
25021         if (flags & NDR_OUT) {
25022                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25023                         NDR_PULL_ALLOC(ndr, r->out.handle);
25024                 }
25025                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25026                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25027                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25028                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25029                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25030         }
25031         return NDR_ERR_SUCCESS;
25032 }
25033
25034 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
25035 {
25036         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
25037         ndr->depth++;
25038         if (flags & NDR_SET_VALUES) {
25039                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25040         }
25041         if (flags & NDR_IN) {
25042                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
25043                 ndr->depth++;
25044                 ndr_print_ptr(ndr, "handle", r->in.handle);
25045                 ndr->depth++;
25046                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25047                 ndr->depth--;
25048                 ndr->depth--;
25049         }
25050         if (flags & NDR_OUT) {
25051                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
25052                 ndr->depth++;
25053                 ndr_print_ptr(ndr, "handle", r->out.handle);
25054                 ndr->depth++;
25055                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25056                 ndr->depth--;
25057                 ndr_print_WERROR(ndr, "result", r->out.result);
25058                 ndr->depth--;
25059         }
25060         ndr->depth--;
25061 }
25062
25063 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
25064 {
25065         if (flags & NDR_IN) {
25066         }
25067         if (flags & NDR_OUT) {
25068                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25069         }
25070         return NDR_ERR_SUCCESS;
25071 }
25072
25073 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
25074 {
25075         if (flags & NDR_IN) {
25076         }
25077         if (flags & NDR_OUT) {
25078                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25079         }
25080         return NDR_ERR_SUCCESS;
25081 }
25082
25083 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
25084 {
25085         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
25086         ndr->depth++;
25087         if (flags & NDR_SET_VALUES) {
25088                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25089         }
25090         if (flags & NDR_IN) {
25091                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
25092                 ndr->depth++;
25093                 ndr->depth--;
25094         }
25095         if (flags & NDR_OUT) {
25096                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
25097                 ndr->depth++;
25098                 ndr_print_WERROR(ndr, "result", r->out.result);
25099                 ndr->depth--;
25100         }
25101         ndr->depth--;
25102 }
25103
25104 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25105 {
25106         if (flags & NDR_IN) {
25107         }
25108         if (flags & NDR_OUT) {
25109                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25110         }
25111         return NDR_ERR_SUCCESS;
25112 }
25113
25114 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25115 {
25116         if (flags & NDR_IN) {
25117         }
25118         if (flags & NDR_OUT) {
25119                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25120         }
25121         return NDR_ERR_SUCCESS;
25122 }
25123
25124 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25125 {
25126         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
25127         ndr->depth++;
25128         if (flags & NDR_SET_VALUES) {
25129                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25130         }
25131         if (flags & NDR_IN) {
25132                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
25133                 ndr->depth++;
25134                 ndr->depth--;
25135         }
25136         if (flags & NDR_OUT) {
25137                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
25138                 ndr->depth++;
25139                 ndr_print_WERROR(ndr, "result", r->out.result);
25140                 ndr->depth--;
25141         }
25142         ndr->depth--;
25143 }
25144
25145 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
25146 {
25147         if (flags & NDR_IN) {
25148         }
25149         if (flags & NDR_OUT) {
25150                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25151         }
25152         return NDR_ERR_SUCCESS;
25153 }
25154
25155 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
25156 {
25157         if (flags & NDR_IN) {
25158         }
25159         if (flags & NDR_OUT) {
25160                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25161         }
25162         return NDR_ERR_SUCCESS;
25163 }
25164
25165 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
25166 {
25167         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
25168         ndr->depth++;
25169         if (flags & NDR_SET_VALUES) {
25170                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25171         }
25172         if (flags & NDR_IN) {
25173                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
25174                 ndr->depth++;
25175                 ndr->depth--;
25176         }
25177         if (flags & NDR_OUT) {
25178                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
25179                 ndr->depth++;
25180                 ndr_print_WERROR(ndr, "result", r->out.result);
25181                 ndr->depth--;
25182         }
25183         ndr->depth--;
25184 }
25185
25186 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
25187 {
25188         if (flags & NDR_IN) {
25189         }
25190         if (flags & NDR_OUT) {
25191                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25192         }
25193         return NDR_ERR_SUCCESS;
25194 }
25195
25196 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
25197 {
25198         if (flags & NDR_IN) {
25199         }
25200         if (flags & NDR_OUT) {
25201                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25202         }
25203         return NDR_ERR_SUCCESS;
25204 }
25205
25206 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
25207 {
25208         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
25209         ndr->depth++;
25210         if (flags & NDR_SET_VALUES) {
25211                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25212         }
25213         if (flags & NDR_IN) {
25214                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
25215                 ndr->depth++;
25216                 ndr->depth--;
25217         }
25218         if (flags & NDR_OUT) {
25219                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
25220                 ndr->depth++;
25221                 ndr_print_WERROR(ndr, "result", r->out.result);
25222                 ndr->depth--;
25223         }
25224         ndr->depth--;
25225 }
25226
25227 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25228 {
25229         if (flags & NDR_IN) {
25230                 if (r->in.handle == NULL) {
25231                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25232                 }
25233                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25234                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25235                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
25236                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
25237                 if (r->in.local_machine) {
25238                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25239                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25240                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25241                         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));
25242                 }
25243                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25244                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
25245                 if (r->in.notify_options) {
25246                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25247                 }
25248         }
25249         if (flags & NDR_OUT) {
25250                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25251         }
25252         return NDR_ERR_SUCCESS;
25253 }
25254
25255 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25256 {
25257         uint32_t _ptr_local_machine;
25258         uint32_t _ptr_notify_options;
25259         TALLOC_CTX *_mem_save_handle_0;
25260         TALLOC_CTX *_mem_save_local_machine_0;
25261         TALLOC_CTX *_mem_save_notify_options_0;
25262         if (flags & NDR_IN) {
25263                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25264                         NDR_PULL_ALLOC(ndr, r->in.handle);
25265                 }
25266                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25267                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25268                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25269                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25270                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25271                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
25272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
25273                 if (_ptr_local_machine) {
25274                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
25275                 } else {
25276                         r->in.local_machine = NULL;
25277                 }
25278                 if (r->in.local_machine) {
25279                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
25280                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
25281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
25282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
25283                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
25284                                 return 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));
25285                         }
25286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
25287                         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));
25288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
25289                 }
25290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25291                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
25292                 if (_ptr_notify_options) {
25293                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
25294                 } else {
25295                         r->in.notify_options = NULL;
25296                 }
25297                 if (r->in.notify_options) {
25298                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25299                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
25300                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
25302                 }
25303         }
25304         if (flags & NDR_OUT) {
25305                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25306         }
25307         return NDR_ERR_SUCCESS;
25308 }
25309
25310 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25311 {
25312         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25313         ndr->depth++;
25314         if (flags & NDR_SET_VALUES) {
25315                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25316         }
25317         if (flags & NDR_IN) {
25318                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25319                 ndr->depth++;
25320                 ndr_print_ptr(ndr, "handle", r->in.handle);
25321                 ndr->depth++;
25322                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25323                 ndr->depth--;
25324                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25325                 ndr_print_uint32(ndr, "options", r->in.options);
25326                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
25327                 ndr->depth++;
25328                 if (r->in.local_machine) {
25329                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
25330                 }
25331                 ndr->depth--;
25332                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25333                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
25334                 ndr->depth++;
25335                 if (r->in.notify_options) {
25336                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
25337                 }
25338                 ndr->depth--;
25339                 ndr->depth--;
25340         }
25341         if (flags & NDR_OUT) {
25342                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25343                 ndr->depth++;
25344                 ndr_print_WERROR(ndr, "result", r->out.result);
25345                 ndr->depth--;
25346         }
25347         ndr->depth--;
25348 }
25349
25350 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25351 {
25352         if (flags & NDR_IN) {
25353                 if (r->in.handle == NULL) {
25354                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25355                 }
25356                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
25358                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25359                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
25360                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25361                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25362         }
25363         if (flags & NDR_OUT) {
25364                 if (r->out.reply_result == NULL) {
25365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25366                 }
25367                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
25368                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25369         }
25370         return NDR_ERR_SUCCESS;
25371 }
25372
25373 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
25374 {
25375         TALLOC_CTX *_mem_save_handle_0;
25376         TALLOC_CTX *_mem_save_reply_result_0;
25377         if (flags & NDR_IN) {
25378                 ZERO_STRUCT(r->out);
25379
25380                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25381                         NDR_PULL_ALLOC(ndr, r->in.handle);
25382                 }
25383                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25384                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25385                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25386                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
25388                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
25390                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25391                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25392                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
25393                 ZERO_STRUCTP(r->out.reply_result);
25394         }
25395         if (flags & NDR_OUT) {
25396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25397                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
25398                 }
25399                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
25400                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
25401                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
25402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
25403                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25404         }
25405         return NDR_ERR_SUCCESS;
25406 }
25407
25408 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25409 {
25410         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
25411         ndr->depth++;
25412         if (flags & NDR_SET_VALUES) {
25413                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25414         }
25415         if (flags & NDR_IN) {
25416                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25417                 ndr->depth++;
25418                 ndr_print_ptr(ndr, "handle", r->in.handle);
25419                 ndr->depth++;
25420                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25421                 ndr->depth--;
25422                 ndr_print_uint32(ndr, "color", r->in.color);
25423                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25424                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25425                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25426                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25427                 ndr->depth--;
25428         }
25429         if (flags & NDR_OUT) {
25430                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25431                 ndr->depth++;
25432                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25433                 ndr->depth++;
25434                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25435                 ndr->depth--;
25436                 ndr_print_WERROR(ndr, "result", r->out.result);
25437                 ndr->depth--;
25438         }
25439         ndr->depth--;
25440 }
25441
25442 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25443 {
25444         if (flags & NDR_IN) {
25445                 if (r->in.handle == NULL) {
25446                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25447                 }
25448                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25450                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25451                 if (r->in.options) {
25452                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25453                 }
25454         }
25455         if (flags & NDR_OUT) {
25456                 if (r->out.info == NULL) {
25457                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25458                 }
25459                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25460                 if (*r->out.info) {
25461                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25462                 }
25463                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25464         }
25465         return NDR_ERR_SUCCESS;
25466 }
25467
25468 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25469 {
25470         uint32_t _ptr_options;
25471         uint32_t _ptr_info;
25472         TALLOC_CTX *_mem_save_handle_0;
25473         TALLOC_CTX *_mem_save_options_0;
25474         TALLOC_CTX *_mem_save_info_0;
25475         TALLOC_CTX *_mem_save_info_1;
25476         if (flags & NDR_IN) {
25477                 ZERO_STRUCT(r->out);
25478
25479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25480                         NDR_PULL_ALLOC(ndr, r->in.handle);
25481                 }
25482                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25483                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25484                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25486                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25487                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25488                 if (_ptr_options) {
25489                         NDR_PULL_ALLOC(ndr, r->in.options);
25490                 } else {
25491                         r->in.options = NULL;
25492                 }
25493                 if (r->in.options) {
25494                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25495                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25496                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25498                 }
25499                 NDR_PULL_ALLOC(ndr, r->out.info);
25500                 ZERO_STRUCTP(r->out.info);
25501         }
25502         if (flags & NDR_OUT) {
25503                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25504                         NDR_PULL_ALLOC(ndr, r->out.info);
25505                 }
25506                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25507                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25509                 if (_ptr_info) {
25510                         NDR_PULL_ALLOC(ndr, *r->out.info);
25511                 } else {
25512                         *r->out.info = NULL;
25513                 }
25514                 if (*r->out.info) {
25515                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25516                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25517                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25518                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25519                 }
25520                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25521                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25522         }
25523         return NDR_ERR_SUCCESS;
25524 }
25525
25526 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25527 {
25528         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25529         ndr->depth++;
25530         if (flags & NDR_SET_VALUES) {
25531                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25532         }
25533         if (flags & NDR_IN) {
25534                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25535                 ndr->depth++;
25536                 ndr_print_ptr(ndr, "handle", r->in.handle);
25537                 ndr->depth++;
25538                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25539                 ndr->depth--;
25540                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25541                 ndr_print_ptr(ndr, "options", r->in.options);
25542                 ndr->depth++;
25543                 if (r->in.options) {
25544                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25545                 }
25546                 ndr->depth--;
25547                 ndr->depth--;
25548         }
25549         if (flags & NDR_OUT) {
25550                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25551                 ndr->depth++;
25552                 ndr_print_ptr(ndr, "info", r->out.info);
25553                 ndr->depth++;
25554                 ndr_print_ptr(ndr, "info", *r->out.info);
25555                 ndr->depth++;
25556                 if (*r->out.info) {
25557                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25558                 }
25559                 ndr->depth--;
25560                 ndr->depth--;
25561                 ndr_print_WERROR(ndr, "result", r->out.result);
25562                 ndr->depth--;
25563         }
25564         ndr->depth--;
25565 }
25566
25567 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25568 {
25569         if (flags & NDR_IN) {
25570         }
25571         if (flags & NDR_OUT) {
25572                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25573         }
25574         return NDR_ERR_SUCCESS;
25575 }
25576
25577 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25578 {
25579         if (flags & NDR_IN) {
25580         }
25581         if (flags & NDR_OUT) {
25582                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25583         }
25584         return NDR_ERR_SUCCESS;
25585 }
25586
25587 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25588 {
25589         ndr_print_struct(ndr, name, "spoolss_44");
25590         ndr->depth++;
25591         if (flags & NDR_SET_VALUES) {
25592                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25593         }
25594         if (flags & NDR_IN) {
25595                 ndr_print_struct(ndr, "in", "spoolss_44");
25596                 ndr->depth++;
25597                 ndr->depth--;
25598         }
25599         if (flags & NDR_OUT) {
25600                 ndr_print_struct(ndr, "out", "spoolss_44");
25601                 ndr->depth++;
25602                 ndr_print_WERROR(ndr, "result", r->out.result);
25603                 ndr->depth--;
25604         }
25605         ndr->depth--;
25606 }
25607
25608 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25609 {
25610         if (flags & NDR_IN) {
25611                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25612                 if (r->in.printername) {
25613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25615                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25616                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25617                 }
25618                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25619                 if (r->in.datatype) {
25620                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25621                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25623                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25624                 }
25625                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25626                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25627                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25628                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25629                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25630         }
25631         if (flags & NDR_OUT) {
25632                 if (r->out.handle == NULL) {
25633                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25634                 }
25635                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25636                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25637         }
25638         return NDR_ERR_SUCCESS;
25639 }
25640
25641 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25642 {
25643         uint32_t _ptr_printername;
25644         uint32_t _ptr_datatype;
25645         TALLOC_CTX *_mem_save_printername_0;
25646         TALLOC_CTX *_mem_save_datatype_0;
25647         TALLOC_CTX *_mem_save_handle_0;
25648         if (flags & NDR_IN) {
25649                 ZERO_STRUCT(r->out);
25650
25651                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25652                 if (_ptr_printername) {
25653                         NDR_PULL_ALLOC(ndr, r->in.printername);
25654                 } else {
25655                         r->in.printername = NULL;
25656                 }
25657                 if (r->in.printername) {
25658                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25659                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25660                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25661                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25662                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25663                                 return 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));
25664                         }
25665                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25666                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25667                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25668                 }
25669                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25670                 if (_ptr_datatype) {
25671                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25672                 } else {
25673                         r->in.datatype = NULL;
25674                 }
25675                 if (r->in.datatype) {
25676                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25677                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25680                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25681                                 return 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));
25682                         }
25683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25686                 }
25687                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25688                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25689                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25690                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25691                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25692                 NDR_PULL_ALLOC(ndr, r->out.handle);
25693                 ZERO_STRUCTP(r->out.handle);
25694         }
25695         if (flags & NDR_OUT) {
25696                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25697                         NDR_PULL_ALLOC(ndr, r->out.handle);
25698                 }
25699                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25700                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25701                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25702                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25703                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25704         }
25705         return NDR_ERR_SUCCESS;
25706 }
25707
25708 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25709 {
25710         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25711         ndr->depth++;
25712         if (flags & NDR_SET_VALUES) {
25713                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25714         }
25715         if (flags & NDR_IN) {
25716                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25717                 ndr->depth++;
25718                 ndr_print_ptr(ndr, "printername", r->in.printername);
25719                 ndr->depth++;
25720                 if (r->in.printername) {
25721                         ndr_print_string(ndr, "printername", r->in.printername);
25722                 }
25723                 ndr->depth--;
25724                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25725                 ndr->depth++;
25726                 if (r->in.datatype) {
25727                         ndr_print_string(ndr, "datatype", r->in.datatype);
25728                 }
25729                 ndr->depth--;
25730                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25731                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25732                 ndr_print_uint32(ndr, "level", r->in.level);
25733                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25734                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25735                 ndr->depth--;
25736         }
25737         if (flags & NDR_OUT) {
25738                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25739                 ndr->depth++;
25740                 ndr_print_ptr(ndr, "handle", r->out.handle);
25741                 ndr->depth++;
25742                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25743                 ndr->depth--;
25744                 ndr_print_WERROR(ndr, "result", r->out.result);
25745                 ndr->depth--;
25746         }
25747         ndr->depth--;
25748 }
25749
25750 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25751 {
25752         if (flags & NDR_IN) {
25753                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25754                 if (r->in.server) {
25755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25758                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25759                 }
25760                 if (r->in.info_ctr == NULL) {
25761                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25762                 }
25763                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25764                 if (r->in.devmode_ctr == NULL) {
25765                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25766                 }
25767                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25768                 if (r->in.secdesc_ctr == NULL) {
25769                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25770                 }
25771                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25772                 if (r->in.userlevel_ctr == NULL) {
25773                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25774                 }
25775                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25776         }
25777         if (flags & NDR_OUT) {
25778                 if (r->out.handle == NULL) {
25779                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25780                 }
25781                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25782                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25783         }
25784         return NDR_ERR_SUCCESS;
25785 }
25786
25787 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25788 {
25789         uint32_t _ptr_server;
25790         TALLOC_CTX *_mem_save_server_0;
25791         TALLOC_CTX *_mem_save_info_ctr_0;
25792         TALLOC_CTX *_mem_save_devmode_ctr_0;
25793         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25794         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25795         TALLOC_CTX *_mem_save_handle_0;
25796         if (flags & NDR_IN) {
25797                 ZERO_STRUCT(r->out);
25798
25799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25800                 if (_ptr_server) {
25801                         NDR_PULL_ALLOC(ndr, r->in.server);
25802                 } else {
25803                         r->in.server = NULL;
25804                 }
25805                 if (r->in.server) {
25806                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25807                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25809                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25810                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25811                                 return 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));
25812                         }
25813                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25814                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25816                 }
25817                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25818                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25819                 }
25820                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25821                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25822                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25823                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25824                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25825                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25826                 }
25827                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25828                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25829                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25830                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25832                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25833                 }
25834                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25835                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25836                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25839                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25840                 }
25841                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25842                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25843                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25844                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25845                 NDR_PULL_ALLOC(ndr, r->out.handle);
25846                 ZERO_STRUCTP(r->out.handle);
25847         }
25848         if (flags & NDR_OUT) {
25849                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25850                         NDR_PULL_ALLOC(ndr, r->out.handle);
25851                 }
25852                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25853                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25854                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25855                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25856                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25857         }
25858         return NDR_ERR_SUCCESS;
25859 }
25860
25861 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25862 {
25863         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25864         ndr->depth++;
25865         if (flags & NDR_SET_VALUES) {
25866                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25867         }
25868         if (flags & NDR_IN) {
25869                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25870                 ndr->depth++;
25871                 ndr_print_ptr(ndr, "server", r->in.server);
25872                 ndr->depth++;
25873                 if (r->in.server) {
25874                         ndr_print_string(ndr, "server", r->in.server);
25875                 }
25876                 ndr->depth--;
25877                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25878                 ndr->depth++;
25879                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25880                 ndr->depth--;
25881                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25882                 ndr->depth++;
25883                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25884                 ndr->depth--;
25885                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25886                 ndr->depth++;
25887                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25888                 ndr->depth--;
25889                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25890                 ndr->depth++;
25891                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25892                 ndr->depth--;
25893                 ndr->depth--;
25894         }
25895         if (flags & NDR_OUT) {
25896                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25897                 ndr->depth++;
25898                 ndr_print_ptr(ndr, "handle", r->out.handle);
25899                 ndr->depth++;
25900                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25901                 ndr->depth--;
25902                 ndr_print_WERROR(ndr, "result", r->out.result);
25903                 ndr->depth--;
25904         }
25905         ndr->depth--;
25906 }
25907
25908 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25909 {
25910         if (flags & NDR_IN) {
25911         }
25912         if (flags & NDR_OUT) {
25913                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25914         }
25915         return NDR_ERR_SUCCESS;
25916 }
25917
25918 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25919 {
25920         if (flags & NDR_IN) {
25921         }
25922         if (flags & NDR_OUT) {
25923                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25924         }
25925         return NDR_ERR_SUCCESS;
25926 }
25927
25928 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25929 {
25930         ndr_print_struct(ndr, name, "spoolss_47");
25931         ndr->depth++;
25932         if (flags & NDR_SET_VALUES) {
25933                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25934         }
25935         if (flags & NDR_IN) {
25936                 ndr_print_struct(ndr, "in", "spoolss_47");
25937                 ndr->depth++;
25938                 ndr->depth--;
25939         }
25940         if (flags & NDR_OUT) {
25941                 ndr_print_struct(ndr, "out", "spoolss_47");
25942                 ndr->depth++;
25943                 ndr_print_WERROR(ndr, "result", r->out.result);
25944                 ndr->depth--;
25945         }
25946         ndr->depth--;
25947 }
25948
25949 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25950 {
25951         if (flags & NDR_IN) {
25952                 if (r->in.handle == NULL) {
25953                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25954                 }
25955                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25959         }
25960         if (flags & NDR_OUT) {
25961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25962                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25963                 if (r->out.value_needed == NULL) {
25964                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25965                 }
25966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25967                 if (r->out.type == NULL) {
25968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25969                 }
25970                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
25971                 {
25972                         uint32_t _flags_save_uint8 = ndr->flags;
25973                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25974                         if (r->out.data == NULL) {
25975                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25976                         }
25977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25978                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
25979                         ndr->flags = _flags_save_uint8;
25980                 }
25981                 if (r->out.data_needed == NULL) {
25982                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25983                 }
25984                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25985                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25986         }
25987         return NDR_ERR_SUCCESS;
25988 }
25989
25990 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25991 {
25992         TALLOC_CTX *_mem_save_handle_0;
25993         TALLOC_CTX *_mem_save_value_needed_0;
25994         TALLOC_CTX *_mem_save_type_0;
25995         TALLOC_CTX *_mem_save_data_needed_0;
25996         if (flags & NDR_IN) {
25997                 ZERO_STRUCT(r->out);
25998
25999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26000                         NDR_PULL_ALLOC(ndr, r->in.handle);
26001                 }
26002                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26004                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26006                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
26007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
26008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
26009                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
26010                 ZERO_STRUCTP(r->out.value_needed);
26011                 NDR_PULL_ALLOC(ndr, r->out.type);
26012                 ZERO_STRUCTP(r->out.type);
26013                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
26014                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
26015                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
26016                 ZERO_STRUCTP(r->out.data_needed);
26017         }
26018         if (flags & NDR_OUT) {
26019                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
26020                 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));
26021                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26022                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
26023                 }
26024                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26025                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
26026                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
26027                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
26028                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26029                         NDR_PULL_ALLOC(ndr, r->out.type);
26030                 }
26031                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26032                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26033                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26034                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26035                 {
26036                         uint32_t _flags_save_uint8 = ndr->flags;
26037                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
26038                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
26039                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26040                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
26041                         }
26042                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
26043                         ndr->flags = _flags_save_uint8;
26044                 }
26045                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26046                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
26047                 }
26048                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26049                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
26050                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
26051                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
26052                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26053                 if (r->out.value_name) {
26054                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
26055                 }
26056                 if (r->out.data) {
26057                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
26058                 }
26059         }
26060         return NDR_ERR_SUCCESS;
26061 }
26062
26063 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
26064 {
26065         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
26066         ndr->depth++;
26067         if (flags & NDR_SET_VALUES) {
26068                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26069         }
26070         if (flags & NDR_IN) {
26071                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
26072                 ndr->depth++;
26073                 ndr_print_ptr(ndr, "handle", r->in.handle);
26074                 ndr->depth++;
26075                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26076                 ndr->depth--;
26077                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
26078                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
26079                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
26080                 ndr->depth--;
26081         }
26082         if (flags & NDR_OUT) {
26083                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
26084                 ndr->depth++;
26085                 ndr_print_string(ndr, "value_name", r->out.value_name);
26086                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
26087                 ndr->depth++;
26088                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
26089                 ndr->depth--;
26090                 ndr_print_ptr(ndr, "type", r->out.type);
26091                 ndr->depth++;
26092                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26093                 ndr->depth--;
26094                 ndr_print_ptr(ndr, "data", r->out.data);
26095                 ndr->depth++;
26096                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
26097                 ndr->depth--;
26098                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
26099                 ndr->depth++;
26100                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
26101                 ndr->depth--;
26102                 ndr_print_WERROR(ndr, "result", r->out.result);
26103                 ndr->depth--;
26104         }
26105         ndr->depth--;
26106 }
26107
26108 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
26109 {
26110         if (flags & NDR_IN) {
26111                 if (r->in.handle == NULL) {
26112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26113                 }
26114                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26117                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26118                 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));
26119         }
26120         if (flags & NDR_OUT) {
26121                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26122         }
26123         return NDR_ERR_SUCCESS;
26124 }
26125
26126 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
26127 {
26128         TALLOC_CTX *_mem_save_handle_0;
26129         if (flags & NDR_IN) {
26130                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26131                         NDR_PULL_ALLOC(ndr, r->in.handle);
26132                 }
26133                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26134                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26135                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26136                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26137                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26138                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26139                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26140                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.value_name), ndr_get_array_length(ndr, &r->in.value_name));
26141                 }
26142                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26143                 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));
26144         }
26145         if (flags & NDR_OUT) {
26146                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26147         }
26148         return NDR_ERR_SUCCESS;
26149 }
26150
26151 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
26152 {
26153         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
26154         ndr->depth++;
26155         if (flags & NDR_SET_VALUES) {
26156                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26157         }
26158         if (flags & NDR_IN) {
26159                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
26160                 ndr->depth++;
26161                 ndr_print_ptr(ndr, "handle", r->in.handle);
26162                 ndr->depth++;
26163                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26164                 ndr->depth--;
26165                 ndr_print_string(ndr, "value_name", r->in.value_name);
26166                 ndr->depth--;
26167         }
26168         if (flags & NDR_OUT) {
26169                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
26170                 ndr->depth++;
26171                 ndr_print_WERROR(ndr, "result", r->out.result);
26172                 ndr->depth--;
26173         }
26174         ndr->depth--;
26175 }
26176
26177 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
26178 {
26179         if (flags & NDR_IN) {
26180         }
26181         if (flags & NDR_OUT) {
26182                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26183         }
26184         return NDR_ERR_SUCCESS;
26185 }
26186
26187 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
26188 {
26189         if (flags & NDR_IN) {
26190         }
26191         if (flags & NDR_OUT) {
26192                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26193         }
26194         return NDR_ERR_SUCCESS;
26195 }
26196
26197 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
26198 {
26199         ndr_print_struct(ndr, name, "spoolss_4a");
26200         ndr->depth++;
26201         if (flags & NDR_SET_VALUES) {
26202                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26203         }
26204         if (flags & NDR_IN) {
26205                 ndr_print_struct(ndr, "in", "spoolss_4a");
26206                 ndr->depth++;
26207                 ndr->depth--;
26208         }
26209         if (flags & NDR_OUT) {
26210                 ndr_print_struct(ndr, "out", "spoolss_4a");
26211                 ndr->depth++;
26212                 ndr_print_WERROR(ndr, "result", r->out.result);
26213                 ndr->depth--;
26214         }
26215         ndr->depth--;
26216 }
26217
26218 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
26219 {
26220         if (flags & NDR_IN) {
26221         }
26222         if (flags & NDR_OUT) {
26223                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26224         }
26225         return NDR_ERR_SUCCESS;
26226 }
26227
26228 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
26229 {
26230         if (flags & NDR_IN) {
26231         }
26232         if (flags & NDR_OUT) {
26233                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26234         }
26235         return NDR_ERR_SUCCESS;
26236 }
26237
26238 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
26239 {
26240         ndr_print_struct(ndr, name, "spoolss_4b");
26241         ndr->depth++;
26242         if (flags & NDR_SET_VALUES) {
26243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26244         }
26245         if (flags & NDR_IN) {
26246                 ndr_print_struct(ndr, "in", "spoolss_4b");
26247                 ndr->depth++;
26248                 ndr->depth--;
26249         }
26250         if (flags & NDR_OUT) {
26251                 ndr_print_struct(ndr, "out", "spoolss_4b");
26252                 ndr->depth++;
26253                 ndr_print_WERROR(ndr, "result", r->out.result);
26254                 ndr->depth--;
26255         }
26256         ndr->depth--;
26257 }
26258
26259 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
26260 {
26261         if (flags & NDR_IN) {
26262         }
26263         if (flags & NDR_OUT) {
26264                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26265         }
26266         return NDR_ERR_SUCCESS;
26267 }
26268
26269 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
26270 {
26271         if (flags & NDR_IN) {
26272         }
26273         if (flags & NDR_OUT) {
26274                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26275         }
26276         return NDR_ERR_SUCCESS;
26277 }
26278
26279 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
26280 {
26281         ndr_print_struct(ndr, name, "spoolss_4c");
26282         ndr->depth++;
26283         if (flags & NDR_SET_VALUES) {
26284                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26285         }
26286         if (flags & NDR_IN) {
26287                 ndr_print_struct(ndr, "in", "spoolss_4c");
26288                 ndr->depth++;
26289                 ndr->depth--;
26290         }
26291         if (flags & NDR_OUT) {
26292                 ndr_print_struct(ndr, "out", "spoolss_4c");
26293                 ndr->depth++;
26294                 ndr_print_WERROR(ndr, "result", r->out.result);
26295                 ndr->depth--;
26296         }
26297         ndr->depth--;
26298 }
26299
26300 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
26301 {
26302         if (flags & NDR_IN) {
26303                 if (r->in.handle == NULL) {
26304                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26305                 }
26306                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26309                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26310                 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));
26311                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26312                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26314                 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));
26315                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26316                 if (r->in.buffer == NULL) {
26317                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26318                 }
26319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26320                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
26321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26322         }
26323         if (flags & NDR_OUT) {
26324                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26325         }
26326         return NDR_ERR_SUCCESS;
26327 }
26328
26329 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
26330 {
26331         TALLOC_CTX *_mem_save_handle_0;
26332         if (flags & NDR_IN) {
26333                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26334                         NDR_PULL_ALLOC(ndr, r->in.handle);
26335                 }
26336                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26337                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26338                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26339                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26340                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26341                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26342                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26343                         return 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));
26344                 }
26345                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26346                 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));
26347                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26348                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26349                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26350                         return 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));
26351                 }
26352                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26353                 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));
26354                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26355                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26357                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26358                 }
26359                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26360                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26361                 if (r->in.buffer) {
26362                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
26363                 }
26364         }
26365         if (flags & NDR_OUT) {
26366                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26367         }
26368         return NDR_ERR_SUCCESS;
26369 }
26370
26371 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
26372 {
26373         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
26374         ndr->depth++;
26375         if (flags & NDR_SET_VALUES) {
26376                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26377         }
26378         if (flags & NDR_IN) {
26379                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
26380                 ndr->depth++;
26381                 ndr_print_ptr(ndr, "handle", r->in.handle);
26382                 ndr->depth++;
26383                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26384                 ndr->depth--;
26385                 ndr_print_string(ndr, "key_name", r->in.key_name);
26386                 ndr_print_string(ndr, "value_name", r->in.value_name);
26387                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26388                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26389                 ndr->depth++;
26390                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
26391                 ndr->depth--;
26392                 ndr_print_uint32(ndr, "offered", r->in.offered);
26393                 ndr->depth--;
26394         }
26395         if (flags & NDR_OUT) {
26396                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
26397                 ndr->depth++;
26398                 ndr_print_WERROR(ndr, "result", r->out.result);
26399                 ndr->depth--;
26400         }
26401         ndr->depth--;
26402 }
26403
26404 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
26405 {
26406         if (flags & NDR_IN) {
26407                 if (r->in.handle == NULL) {
26408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26409                 }
26410                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26414                 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));
26415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26418                 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));
26419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26420         }
26421         if (flags & NDR_OUT) {
26422                 if (r->out.type == NULL) {
26423                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26424                 }
26425                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26426                 if (r->out.buffer == NULL) {
26427                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26428                 }
26429                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26430                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26431                 if (r->out.needed == NULL) {
26432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26433                 }
26434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26435                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26436         }
26437         return NDR_ERR_SUCCESS;
26438 }
26439
26440 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26441 {
26442         TALLOC_CTX *_mem_save_handle_0;
26443         TALLOC_CTX *_mem_save_type_0;
26444         TALLOC_CTX *_mem_save_needed_0;
26445         if (flags & NDR_IN) {
26446                 ZERO_STRUCT(r->out);
26447
26448                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26449                         NDR_PULL_ALLOC(ndr, r->in.handle);
26450                 }
26451                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26452                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26453                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26455                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26456                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26457                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26458                         return 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));
26459                 }
26460                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26461                 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));
26462                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26463                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26464                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26465                         return 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));
26466                 }
26467                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26468                 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));
26469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26470                 NDR_PULL_ALLOC(ndr, r->out.type);
26471                 ZERO_STRUCTP(r->out.type);
26472                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26473                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26474                 NDR_PULL_ALLOC(ndr, r->out.needed);
26475                 ZERO_STRUCTP(r->out.needed);
26476         }
26477         if (flags & NDR_OUT) {
26478                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26479                         NDR_PULL_ALLOC(ndr, r->out.type);
26480                 }
26481                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26482                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26483                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26484                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26485                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26486                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26487                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26488                 }
26489                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26490                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26491                         NDR_PULL_ALLOC(ndr, r->out.needed);
26492                 }
26493                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26494                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26496                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26497                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26498                 if (r->out.buffer) {
26499                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26500                 }
26501         }
26502         return NDR_ERR_SUCCESS;
26503 }
26504
26505 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26506 {
26507         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26508         ndr->depth++;
26509         if (flags & NDR_SET_VALUES) {
26510                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26511         }
26512         if (flags & NDR_IN) {
26513                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26514                 ndr->depth++;
26515                 ndr_print_ptr(ndr, "handle", r->in.handle);
26516                 ndr->depth++;
26517                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26518                 ndr->depth--;
26519                 ndr_print_string(ndr, "key_name", r->in.key_name);
26520                 ndr_print_string(ndr, "value_name", r->in.value_name);
26521                 ndr_print_uint32(ndr, "offered", r->in.offered);
26522                 ndr->depth--;
26523         }
26524         if (flags & NDR_OUT) {
26525                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26526                 ndr->depth++;
26527                 ndr_print_ptr(ndr, "type", r->out.type);
26528                 ndr->depth++;
26529                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26530                 ndr->depth--;
26531                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26532                 ndr->depth++;
26533                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26534                 ndr->depth--;
26535                 ndr_print_ptr(ndr, "needed", r->out.needed);
26536                 ndr->depth++;
26537                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26538                 ndr->depth--;
26539                 ndr_print_WERROR(ndr, "result", r->out.result);
26540                 ndr->depth--;
26541         }
26542         ndr->depth--;
26543 }
26544
26545 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
26546 {
26547         if (flags & NDR_IN) {
26548                 if (r->in.handle == NULL) {
26549                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26550                 }
26551                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26552                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26553                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26555                 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));
26556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26557         }
26558         if (flags & NDR_OUT) {
26559                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26560                 if (r->out.needed == NULL) {
26561                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26562                 }
26563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26564                 if (r->out.count == NULL) {
26565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26566                 }
26567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26568                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26569         }
26570         return NDR_ERR_SUCCESS;
26571 }
26572
26573 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
26574 {
26575         TALLOC_CTX *_mem_save_handle_0;
26576         TALLOC_CTX *_mem_save_needed_0;
26577         TALLOC_CTX *_mem_save_count_0;
26578         if (flags & NDR_IN) {
26579                 ZERO_STRUCT(r->out);
26580
26581                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26582                         NDR_PULL_ALLOC(ndr, r->in.handle);
26583                 }
26584                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26585                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26586                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26587                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26588                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26589                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26590                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26591                         return 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));
26592                 }
26593                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26594                 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));
26595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26596                 NDR_PULL_ALLOC(ndr, r->out.needed);
26597                 ZERO_STRUCTP(r->out.needed);
26598                 NDR_PULL_ALLOC(ndr, r->out.count);
26599                 ZERO_STRUCTP(r->out.count);
26600         }
26601         if (flags & NDR_OUT) {
26602                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
26603                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26604                         NDR_PULL_ALLOC(ndr, r->out.needed);
26605                 }
26606                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26607                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26609                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26610                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26611                         NDR_PULL_ALLOC(ndr, r->out.count);
26612                 }
26613                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26614                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26616                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26617                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26618         }
26619         return NDR_ERR_SUCCESS;
26620 }
26621
26622 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
26623 {
26624         uint32_t cntr_info_0;
26625         if (flags & NDR_IN) {
26626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26627         }
26628         if (flags & NDR_OUT) {
26629                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26630                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26631                 }
26632                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26633                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26634                 }
26635         }
26636         return NDR_ERR_SUCCESS;
26637 }
26638
26639 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
26640 {
26641         uint32_t cntr_info_0;
26642         TALLOC_CTX *_mem_save_info_0;
26643         if (flags & NDR_IN) {
26644                 ZERO_STRUCT(r->out);
26645
26646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26647         }
26648         if (flags & NDR_OUT) {
26649                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26650                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26651                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26652                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26653                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26654                 }
26655                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26656                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26657                 }
26658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26659         }
26660         return NDR_ERR_SUCCESS;
26661 }
26662
26663 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26664 {
26665         uint32_t cntr_info_2;
26666         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26667         ndr->depth++;
26668         if (flags & NDR_SET_VALUES) {
26669                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26670         }
26671         if (flags & NDR_IN) {
26672                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26673                 ndr->depth++;
26674                 ndr_print_ptr(ndr, "handle", r->in.handle);
26675                 ndr->depth++;
26676                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26677                 ndr->depth--;
26678                 ndr_print_string(ndr, "key_name", r->in.key_name);
26679                 ndr_print_uint32(ndr, "offered", r->in.offered);
26680                 ndr->depth--;
26681         }
26682         if (flags & NDR_OUT) {
26683                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26684                 ndr->depth++;
26685                 ndr_print_ptr(ndr, "count", r->out.count);
26686                 ndr->depth++;
26687                 ndr_print_uint32(ndr, "count", *r->out.count);
26688                 ndr->depth--;
26689                 ndr_print_ptr(ndr, "info", r->out.info);
26690                 ndr->depth++;
26691                 ndr_print_ptr(ndr, "info", *r->out.info);
26692                 ndr->depth++;
26693                 if (*r->out.info) {
26694                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26695                         ndr->depth++;
26696                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26697                                 char *idx_2=NULL;
26698                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26699                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
26700                                         free(idx_2);
26701                                 }
26702                         }
26703                         ndr->depth--;
26704                 }
26705                 ndr->depth--;
26706                 ndr->depth--;
26707                 ndr_print_ptr(ndr, "needed", r->out.needed);
26708                 ndr->depth++;
26709                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26710                 ndr->depth--;
26711                 ndr_print_WERROR(ndr, "result", r->out.result);
26712                 ndr->depth--;
26713         }
26714         ndr->depth--;
26715 }
26716
26717 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26718 {
26719         if (flags & NDR_IN) {
26720                 if (r->in.handle == NULL) {
26721                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26722                 }
26723                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26724                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26725                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26726                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26727                 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));
26728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26729         }
26730         if (flags & NDR_OUT) {
26731                 if (r->out._ndr_size == NULL) {
26732                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26733                 }
26734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
26735                 if (r->out.key_buffer == NULL) {
26736                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26737                 }
26738                 {
26739                         struct ndr_push *_ndr_key_buffer;
26740                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
26741                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
26742                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
26743                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
26744                 }
26745                 if (r->out.needed == NULL) {
26746                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26747                 }
26748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26749                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26750         }
26751         return NDR_ERR_SUCCESS;
26752 }
26753
26754 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26755 {
26756         TALLOC_CTX *_mem_save_handle_0;
26757         TALLOC_CTX *_mem_save__ndr_size_0;
26758         TALLOC_CTX *_mem_save_key_buffer_0;
26759         TALLOC_CTX *_mem_save_needed_0;
26760         if (flags & NDR_IN) {
26761                 ZERO_STRUCT(r->out);
26762
26763                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26764                         NDR_PULL_ALLOC(ndr, r->in.handle);
26765                 }
26766                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26767                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26768                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26769                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26770                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26771                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26772                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26773                         return 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));
26774                 }
26775                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26776                 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));
26777                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26778                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
26779                 ZERO_STRUCTP(r->out._ndr_size);
26780                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26781                 ZERO_STRUCTP(r->out.key_buffer);
26782                 NDR_PULL_ALLOC(ndr, r->out.needed);
26783                 ZERO_STRUCTP(r->out.needed);
26784         }
26785         if (flags & NDR_OUT) {
26786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26787                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
26788                 }
26789                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
26790                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
26791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
26792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
26793                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26794                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26795                 }
26796                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26797                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
26798                 {
26799                         struct ndr_pull *_ndr_key_buffer;
26800                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
26801                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
26802                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
26803                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
26804                 }
26805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
26806                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26807                         NDR_PULL_ALLOC(ndr, r->out.needed);
26808                 }
26809                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26810                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26812                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26813                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26814         }
26815         return NDR_ERR_SUCCESS;
26816 }
26817
26818 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26819 {
26820         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26821         ndr->depth++;
26822         if (flags & NDR_SET_VALUES) {
26823                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26824         }
26825         if (flags & NDR_IN) {
26826                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26827                 ndr->depth++;
26828                 ndr_print_ptr(ndr, "handle", r->in.handle);
26829                 ndr->depth++;
26830                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26831                 ndr->depth--;
26832                 ndr_print_string(ndr, "key_name", r->in.key_name);
26833                 ndr_print_uint32(ndr, "offered", r->in.offered);
26834                 ndr->depth--;
26835         }
26836         if (flags & NDR_OUT) {
26837                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26838                 ndr->depth++;
26839                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
26840                 ndr->depth++;
26841                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
26842                 ndr->depth--;
26843                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26844                 ndr->depth++;
26845                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
26846                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
26847                 ndr->depth--;
26848                 ndr_print_ptr(ndr, "needed", r->out.needed);
26849                 ndr->depth++;
26850                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26851                 ndr->depth--;
26852                 ndr_print_WERROR(ndr, "result", r->out.result);
26853                 ndr->depth--;
26854         }
26855         ndr->depth--;
26856 }
26857
26858 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26859 {
26860         if (flags & NDR_IN) {
26861                 if (r->in.handle == NULL) {
26862                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26863                 }
26864                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26866                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26868                 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));
26869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26871                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26872                 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));
26873         }
26874         if (flags & NDR_OUT) {
26875                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26876         }
26877         return NDR_ERR_SUCCESS;
26878 }
26879
26880 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26881 {
26882         TALLOC_CTX *_mem_save_handle_0;
26883         if (flags & NDR_IN) {
26884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26885                         NDR_PULL_ALLOC(ndr, r->in.handle);
26886                 }
26887                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26888                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26889                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26891                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26892                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26893                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26894                         return 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));
26895                 }
26896                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26897                 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));
26898                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26899                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26900                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26901                         return 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));
26902                 }
26903                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26904                 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));
26905         }
26906         if (flags & NDR_OUT) {
26907                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26908         }
26909         return NDR_ERR_SUCCESS;
26910 }
26911
26912 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26913 {
26914         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26915         ndr->depth++;
26916         if (flags & NDR_SET_VALUES) {
26917                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26918         }
26919         if (flags & NDR_IN) {
26920                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26921                 ndr->depth++;
26922                 ndr_print_ptr(ndr, "handle", r->in.handle);
26923                 ndr->depth++;
26924                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26925                 ndr->depth--;
26926                 ndr_print_string(ndr, "key_name", r->in.key_name);
26927                 ndr_print_string(ndr, "value_name", r->in.value_name);
26928                 ndr->depth--;
26929         }
26930         if (flags & NDR_OUT) {
26931                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26932                 ndr->depth++;
26933                 ndr_print_WERROR(ndr, "result", r->out.result);
26934                 ndr->depth--;
26935         }
26936         ndr->depth--;
26937 }
26938
26939 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26940 {
26941         if (flags & NDR_IN) {
26942                 if (r->in.handle == NULL) {
26943                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26944                 }
26945                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26946                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26947                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26949                 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));
26950         }
26951         if (flags & NDR_OUT) {
26952                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26953         }
26954         return NDR_ERR_SUCCESS;
26955 }
26956
26957 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26958 {
26959         TALLOC_CTX *_mem_save_handle_0;
26960         if (flags & NDR_IN) {
26961                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26962                         NDR_PULL_ALLOC(ndr, r->in.handle);
26963                 }
26964                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26965                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26966                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26967                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26968                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26969                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26970                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26971                         return 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));
26972                 }
26973                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26974                 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));
26975         }
26976         if (flags & NDR_OUT) {
26977                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26978         }
26979         return NDR_ERR_SUCCESS;
26980 }
26981
26982 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26983 {
26984         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26985         ndr->depth++;
26986         if (flags & NDR_SET_VALUES) {
26987                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26988         }
26989         if (flags & NDR_IN) {
26990                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26991                 ndr->depth++;
26992                 ndr_print_ptr(ndr, "handle", r->in.handle);
26993                 ndr->depth++;
26994                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26995                 ndr->depth--;
26996                 ndr_print_string(ndr, "key_name", r->in.key_name);
26997                 ndr->depth--;
26998         }
26999         if (flags & NDR_OUT) {
27000                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
27001                 ndr->depth++;
27002                 ndr_print_WERROR(ndr, "result", r->out.result);
27003                 ndr->depth--;
27004         }
27005         ndr->depth--;
27006 }
27007
27008 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
27009 {
27010         if (flags & NDR_IN) {
27011         }
27012         if (flags & NDR_OUT) {
27013                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27014         }
27015         return NDR_ERR_SUCCESS;
27016 }
27017
27018 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
27019 {
27020         if (flags & NDR_IN) {
27021         }
27022         if (flags & NDR_OUT) {
27023                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27024         }
27025         return NDR_ERR_SUCCESS;
27026 }
27027
27028 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
27029 {
27030         ndr_print_struct(ndr, name, "spoolss_53");
27031         ndr->depth++;
27032         if (flags & NDR_SET_VALUES) {
27033                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27034         }
27035         if (flags & NDR_IN) {
27036                 ndr_print_struct(ndr, "in", "spoolss_53");
27037                 ndr->depth++;
27038                 ndr->depth--;
27039         }
27040         if (flags & NDR_OUT) {
27041                 ndr_print_struct(ndr, "out", "spoolss_53");
27042                 ndr->depth++;
27043                 ndr_print_WERROR(ndr, "result", r->out.result);
27044                 ndr->depth--;
27045         }
27046         ndr->depth--;
27047 }
27048
27049 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27050 {
27051         if (flags & NDR_IN) {
27052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27053                 if (r->in.server) {
27054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
27057                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27058                 }
27059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27060                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27062                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27066                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27067                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
27068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
27069         }
27070         if (flags & NDR_OUT) {
27071                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27072         }
27073         return NDR_ERR_SUCCESS;
27074 }
27075
27076 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
27077 {
27078         uint32_t _ptr_server;
27079         TALLOC_CTX *_mem_save_server_0;
27080         if (flags & NDR_IN) {
27081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27082                 if (_ptr_server) {
27083                         NDR_PULL_ALLOC(ndr, r->in.server);
27084                 } else {
27085                         r->in.server = NULL;
27086                 }
27087                 if (r->in.server) {
27088                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27089                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27090                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27091                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27092                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
27093                                 return 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));
27094                         }
27095                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27096                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27098                 }
27099                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
27100                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
27101                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
27102                         return 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));
27103                 }
27104                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
27105                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
27106                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
27107                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
27108                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
27109                         return 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));
27110                 }
27111                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
27112                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
27113                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
27114                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
27115         }
27116         if (flags & NDR_OUT) {
27117                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27118         }
27119         return NDR_ERR_SUCCESS;
27120 }
27121
27122 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27123 {
27124         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
27125         ndr->depth++;
27126         if (flags & NDR_SET_VALUES) {
27127                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27128         }
27129         if (flags & NDR_IN) {
27130                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
27131                 ndr->depth++;
27132                 ndr_print_ptr(ndr, "server", r->in.server);
27133                 ndr->depth++;
27134                 if (r->in.server) {
27135                         ndr_print_string(ndr, "server", r->in.server);
27136                 }
27137                 ndr->depth--;
27138                 ndr_print_string(ndr, "architecture", r->in.architecture);
27139                 ndr_print_string(ndr, "driver", r->in.driver);
27140                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
27141                 ndr_print_uint32(ndr, "version", r->in.version);
27142                 ndr->depth--;
27143         }
27144         if (flags & NDR_OUT) {
27145                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
27146                 ndr->depth++;
27147                 ndr_print_WERROR(ndr, "result", r->out.result);
27148                 ndr->depth--;
27149         }
27150         ndr->depth--;
27151 }
27152
27153 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
27154 {
27155         if (flags & NDR_IN) {
27156         }
27157         if (flags & NDR_OUT) {
27158                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27159         }
27160         return NDR_ERR_SUCCESS;
27161 }
27162
27163 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
27164 {
27165         if (flags & NDR_IN) {
27166         }
27167         if (flags & NDR_OUT) {
27168                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27169         }
27170         return NDR_ERR_SUCCESS;
27171 }
27172
27173 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
27174 {
27175         ndr_print_struct(ndr, name, "spoolss_55");
27176         ndr->depth++;
27177         if (flags & NDR_SET_VALUES) {
27178                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27179         }
27180         if (flags & NDR_IN) {
27181                 ndr_print_struct(ndr, "in", "spoolss_55");
27182                 ndr->depth++;
27183                 ndr->depth--;
27184         }
27185         if (flags & NDR_OUT) {
27186                 ndr_print_struct(ndr, "out", "spoolss_55");
27187                 ndr->depth++;
27188                 ndr_print_WERROR(ndr, "result", r->out.result);
27189                 ndr->depth--;
27190         }
27191         ndr->depth--;
27192 }
27193
27194 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
27195 {
27196         if (flags & NDR_IN) {
27197         }
27198         if (flags & NDR_OUT) {
27199                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27200         }
27201         return NDR_ERR_SUCCESS;
27202 }
27203
27204 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
27205 {
27206         if (flags & NDR_IN) {
27207         }
27208         if (flags & NDR_OUT) {
27209                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27210         }
27211         return NDR_ERR_SUCCESS;
27212 }
27213
27214 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
27215 {
27216         ndr_print_struct(ndr, name, "spoolss_56");
27217         ndr->depth++;
27218         if (flags & NDR_SET_VALUES) {
27219                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27220         }
27221         if (flags & NDR_IN) {
27222                 ndr_print_struct(ndr, "in", "spoolss_56");
27223                 ndr->depth++;
27224                 ndr->depth--;
27225         }
27226         if (flags & NDR_OUT) {
27227                 ndr_print_struct(ndr, "out", "spoolss_56");
27228                 ndr->depth++;
27229                 ndr_print_WERROR(ndr, "result", r->out.result);
27230                 ndr->depth--;
27231         }
27232         ndr->depth--;
27233 }
27234
27235 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
27236 {
27237         if (flags & NDR_IN) {
27238         }
27239         if (flags & NDR_OUT) {
27240                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27241         }
27242         return NDR_ERR_SUCCESS;
27243 }
27244
27245 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
27246 {
27247         if (flags & NDR_IN) {
27248         }
27249         if (flags & NDR_OUT) {
27250                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27251         }
27252         return NDR_ERR_SUCCESS;
27253 }
27254
27255 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
27256 {
27257         ndr_print_struct(ndr, name, "spoolss_57");
27258         ndr->depth++;
27259         if (flags & NDR_SET_VALUES) {
27260                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27261         }
27262         if (flags & NDR_IN) {
27263                 ndr_print_struct(ndr, "in", "spoolss_57");
27264                 ndr->depth++;
27265                 ndr->depth--;
27266         }
27267         if (flags & NDR_OUT) {
27268                 ndr_print_struct(ndr, "out", "spoolss_57");
27269                 ndr->depth++;
27270                 ndr_print_WERROR(ndr, "result", r->out.result);
27271                 ndr->depth--;
27272         }
27273         ndr->depth--;
27274 }
27275
27276 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
27277 {
27278         if (flags & NDR_IN) {
27279                 if (r->in.handle == NULL) {
27280                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27281                 }
27282                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27286                 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));
27287                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
27288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
27289                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27290                 if (r->in.status_code == NULL) {
27291                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27292                 }
27293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
27294         }
27295         if (flags & NDR_OUT) {
27296                 if (r->out.out_data == NULL) {
27297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27298                 }
27299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27300                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
27301                 if (r->out.needed == NULL) {
27302                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27303                 }
27304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27305                 if (r->out.status_code == NULL) {
27306                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27307                 }
27308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
27309                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27310         }
27311         return NDR_ERR_SUCCESS;
27312 }
27313
27314 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
27315 {
27316         TALLOC_CTX *_mem_save_handle_0;
27317         TALLOC_CTX *_mem_save_needed_0;
27318         TALLOC_CTX *_mem_save_status_code_0;
27319         if (flags & NDR_IN) {
27320                 ZERO_STRUCT(r->out);
27321
27322                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27323                         NDR_PULL_ALLOC(ndr, r->in.handle);
27324                 }
27325                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27326                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27327                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27328                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27329                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
27330                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
27331                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
27332                         return 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));
27333                 }
27334                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
27335                 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));
27336                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
27337                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
27338                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
27339                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27340                         NDR_PULL_ALLOC(ndr, r->in.status_code);
27341                 }
27342                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27343                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
27344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
27345                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27346                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
27347                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
27348                 NDR_PULL_ALLOC(ndr, r->out.needed);
27349                 ZERO_STRUCTP(r->out.needed);
27350                 NDR_PULL_ALLOC(ndr, r->out.status_code);
27351                 *r->out.status_code = *r->in.status_code;
27352         }
27353         if (flags & NDR_OUT) {
27354                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
27355                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27356                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
27357                 }
27358                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
27359                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27360                         NDR_PULL_ALLOC(ndr, r->out.needed);
27361                 }
27362                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27363                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27366                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27367                         NDR_PULL_ALLOC(ndr, r->out.status_code);
27368                 }
27369                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27370                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
27371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
27372                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27373                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27374                 if (r->out.out_data) {
27375                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
27376                 }
27377         }
27378         return NDR_ERR_SUCCESS;
27379 }
27380
27381 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
27382 {
27383         ndr_print_struct(ndr, name, "spoolss_XcvData");
27384         ndr->depth++;
27385         if (flags & NDR_SET_VALUES) {
27386                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27387         }
27388         if (flags & NDR_IN) {
27389                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
27390                 ndr->depth++;
27391                 ndr_print_ptr(ndr, "handle", r->in.handle);
27392                 ndr->depth++;
27393                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27394                 ndr->depth--;
27395                 ndr_print_string(ndr, "function_name", r->in.function_name);
27396                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
27397                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
27398                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
27399                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
27400                 ndr->depth++;
27401                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
27402                 ndr->depth--;
27403                 ndr->depth--;
27404         }
27405         if (flags & NDR_OUT) {
27406                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
27407                 ndr->depth++;
27408                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
27409                 ndr->depth++;
27410                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
27411                 ndr->depth--;
27412                 ndr_print_ptr(ndr, "needed", r->out.needed);
27413                 ndr->depth++;
27414                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27415                 ndr->depth--;
27416                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
27417                 ndr->depth++;
27418                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
27419                 ndr->depth--;
27420                 ndr_print_WERROR(ndr, "result", r->out.result);
27421                 ndr->depth--;
27422         }
27423         ndr->depth--;
27424 }
27425
27426 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
27427 {
27428         if (flags & NDR_IN) {
27429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
27430                 if (r->in.servername) {
27431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27435                 }
27436                 if (r->in.info_ctr == NULL) {
27437                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27438                 }
27439                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27440                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
27441         }
27442         if (flags & NDR_OUT) {
27443                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27444         }
27445         return NDR_ERR_SUCCESS;
27446 }
27447
27448 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
27449 {
27450         uint32_t _ptr_servername;
27451         TALLOC_CTX *_mem_save_servername_0;
27452         TALLOC_CTX *_mem_save_info_ctr_0;
27453         if (flags & NDR_IN) {
27454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
27455                 if (_ptr_servername) {
27456                         NDR_PULL_ALLOC(ndr, r->in.servername);
27457                 } else {
27458                         r->in.servername = NULL;
27459                 }
27460                 if (r->in.servername) {
27461                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27462                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
27463                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
27464                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
27465                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
27466                                 return 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));
27467                         }
27468                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
27469                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
27470                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
27471                 }
27472                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27473                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27474                 }
27475                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27476                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27477                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27478                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27479                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27480         }
27481         if (flags & NDR_OUT) {
27482                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27483         }
27484         return NDR_ERR_SUCCESS;
27485 }
27486
27487 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27488 {
27489         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27490         ndr->depth++;
27491         if (flags & NDR_SET_VALUES) {
27492                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27493         }
27494         if (flags & NDR_IN) {
27495                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27496                 ndr->depth++;
27497                 ndr_print_ptr(ndr, "servername", r->in.servername);
27498                 ndr->depth++;
27499                 if (r->in.servername) {
27500                         ndr_print_string(ndr, "servername", r->in.servername);
27501                 }
27502                 ndr->depth--;
27503                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27504                 ndr->depth++;
27505                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27506                 ndr->depth--;
27507                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
27508                 ndr->depth--;
27509         }
27510         if (flags & NDR_OUT) {
27511                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
27512                 ndr->depth++;
27513                 ndr_print_WERROR(ndr, "result", r->out.result);
27514                 ndr->depth--;
27515         }
27516         ndr->depth--;
27517 }
27518
27519 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
27520 {
27521         if (flags & NDR_IN) {
27522         }
27523         if (flags & NDR_OUT) {
27524                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27525         }
27526         return NDR_ERR_SUCCESS;
27527 }
27528
27529 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27530 {
27531         if (flags & NDR_IN) {
27532         }
27533         if (flags & NDR_OUT) {
27534                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27535         }
27536         return NDR_ERR_SUCCESS;
27537 }
27538
27539 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27540 {
27541         ndr_print_struct(ndr, name, "spoolss_5a");
27542         ndr->depth++;
27543         if (flags & NDR_SET_VALUES) {
27544                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27545         }
27546         if (flags & NDR_IN) {
27547                 ndr_print_struct(ndr, "in", "spoolss_5a");
27548                 ndr->depth++;
27549                 ndr->depth--;
27550         }
27551         if (flags & NDR_OUT) {
27552                 ndr_print_struct(ndr, "out", "spoolss_5a");
27553                 ndr->depth++;
27554                 ndr_print_WERROR(ndr, "result", r->out.result);
27555                 ndr->depth--;
27556         }
27557         ndr->depth--;
27558 }
27559
27560 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27561 {
27562         if (flags & NDR_IN) {
27563         }
27564         if (flags & NDR_OUT) {
27565                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27566         }
27567         return NDR_ERR_SUCCESS;
27568 }
27569
27570 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27571 {
27572         if (flags & NDR_IN) {
27573         }
27574         if (flags & NDR_OUT) {
27575                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27576         }
27577         return NDR_ERR_SUCCESS;
27578 }
27579
27580 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27581 {
27582         ndr_print_struct(ndr, name, "spoolss_5b");
27583         ndr->depth++;
27584         if (flags & NDR_SET_VALUES) {
27585                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27586         }
27587         if (flags & NDR_IN) {
27588                 ndr_print_struct(ndr, "in", "spoolss_5b");
27589                 ndr->depth++;
27590                 ndr->depth--;
27591         }
27592         if (flags & NDR_OUT) {
27593                 ndr_print_struct(ndr, "out", "spoolss_5b");
27594                 ndr->depth++;
27595                 ndr_print_WERROR(ndr, "result", r->out.result);
27596                 ndr->depth--;
27597         }
27598         ndr->depth--;
27599 }
27600
27601 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27602 {
27603         if (flags & NDR_IN) {
27604         }
27605         if (flags & NDR_OUT) {
27606                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27607         }
27608         return NDR_ERR_SUCCESS;
27609 }
27610
27611 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27612 {
27613         if (flags & NDR_IN) {
27614         }
27615         if (flags & NDR_OUT) {
27616                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27617         }
27618         return NDR_ERR_SUCCESS;
27619 }
27620
27621 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27622 {
27623         ndr_print_struct(ndr, name, "spoolss_5c");
27624         ndr->depth++;
27625         if (flags & NDR_SET_VALUES) {
27626                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27627         }
27628         if (flags & NDR_IN) {
27629                 ndr_print_struct(ndr, "in", "spoolss_5c");
27630                 ndr->depth++;
27631                 ndr->depth--;
27632         }
27633         if (flags & NDR_OUT) {
27634                 ndr_print_struct(ndr, "out", "spoolss_5c");
27635                 ndr->depth++;
27636                 ndr_print_WERROR(ndr, "result", r->out.result);
27637                 ndr->depth--;
27638         }
27639         ndr->depth--;
27640 }
27641
27642 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27643 {
27644         if (flags & NDR_IN) {
27645         }
27646         if (flags & NDR_OUT) {
27647                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27648         }
27649         return NDR_ERR_SUCCESS;
27650 }
27651
27652 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27653 {
27654         if (flags & NDR_IN) {
27655         }
27656         if (flags & NDR_OUT) {
27657                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27658         }
27659         return NDR_ERR_SUCCESS;
27660 }
27661
27662 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27663 {
27664         ndr_print_struct(ndr, name, "spoolss_5d");
27665         ndr->depth++;
27666         if (flags & NDR_SET_VALUES) {
27667                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27668         }
27669         if (flags & NDR_IN) {
27670                 ndr_print_struct(ndr, "in", "spoolss_5d");
27671                 ndr->depth++;
27672                 ndr->depth--;
27673         }
27674         if (flags & NDR_OUT) {
27675                 ndr_print_struct(ndr, "out", "spoolss_5d");
27676                 ndr->depth++;
27677                 ndr_print_WERROR(ndr, "result", r->out.result);
27678                 ndr->depth--;
27679         }
27680         ndr->depth--;
27681 }
27682
27683 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27684 {
27685         if (flags & NDR_IN) {
27686         }
27687         if (flags & NDR_OUT) {
27688                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27689         }
27690         return NDR_ERR_SUCCESS;
27691 }
27692
27693 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27694 {
27695         if (flags & NDR_IN) {
27696         }
27697         if (flags & NDR_OUT) {
27698                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27699         }
27700         return NDR_ERR_SUCCESS;
27701 }
27702
27703 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27704 {
27705         ndr_print_struct(ndr, name, "spoolss_5e");
27706         ndr->depth++;
27707         if (flags & NDR_SET_VALUES) {
27708                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27709         }
27710         if (flags & NDR_IN) {
27711                 ndr_print_struct(ndr, "in", "spoolss_5e");
27712                 ndr->depth++;
27713                 ndr->depth--;
27714         }
27715         if (flags & NDR_OUT) {
27716                 ndr_print_struct(ndr, "out", "spoolss_5e");
27717                 ndr->depth++;
27718                 ndr_print_WERROR(ndr, "result", r->out.result);
27719                 ndr->depth--;
27720         }
27721         ndr->depth--;
27722 }
27723
27724 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27725 {
27726         if (flags & NDR_IN) {
27727         }
27728         if (flags & NDR_OUT) {
27729                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27730         }
27731         return NDR_ERR_SUCCESS;
27732 }
27733
27734 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27735 {
27736         if (flags & NDR_IN) {
27737         }
27738         if (flags & NDR_OUT) {
27739                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27740         }
27741         return NDR_ERR_SUCCESS;
27742 }
27743
27744 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27745 {
27746         ndr_print_struct(ndr, name, "spoolss_5f");
27747         ndr->depth++;
27748         if (flags & NDR_SET_VALUES) {
27749                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27750         }
27751         if (flags & NDR_IN) {
27752                 ndr_print_struct(ndr, "in", "spoolss_5f");
27753                 ndr->depth++;
27754                 ndr->depth--;
27755         }
27756         if (flags & NDR_OUT) {
27757                 ndr_print_struct(ndr, "out", "spoolss_5f");
27758                 ndr->depth++;
27759                 ndr_print_WERROR(ndr, "result", r->out.result);
27760                 ndr->depth--;
27761         }
27762         ndr->depth--;
27763 }
27764
27765 static const struct ndr_interface_call spoolss_calls[] = {
27766         {
27767                 "spoolss_EnumPrinters",
27768                 sizeof(struct spoolss_EnumPrinters),
27769                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27770                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27771                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27772                 false,
27773         },
27774         {
27775                 "spoolss_OpenPrinter",
27776                 sizeof(struct spoolss_OpenPrinter),
27777                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27778                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27779                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27780                 false,
27781         },
27782         {
27783                 "spoolss_SetJob",
27784                 sizeof(struct spoolss_SetJob),
27785                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27786                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27787                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27788                 false,
27789         },
27790         {
27791                 "spoolss_GetJob",
27792                 sizeof(struct spoolss_GetJob),
27793                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27794                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27795                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27796                 false,
27797         },
27798         {
27799                 "spoolss_EnumJobs",
27800                 sizeof(struct spoolss_EnumJobs),
27801                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27802                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27803                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27804                 false,
27805         },
27806         {
27807                 "spoolss_AddPrinter",
27808                 sizeof(struct spoolss_AddPrinter),
27809                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27810                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27811                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27812                 false,
27813         },
27814         {
27815                 "spoolss_DeletePrinter",
27816                 sizeof(struct spoolss_DeletePrinter),
27817                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27818                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27819                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27820                 false,
27821         },
27822         {
27823                 "spoolss_SetPrinter",
27824                 sizeof(struct spoolss_SetPrinter),
27825                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27826                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27827                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27828                 false,
27829         },
27830         {
27831                 "spoolss_GetPrinter",
27832                 sizeof(struct spoolss_GetPrinter),
27833                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27834                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27835                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27836                 false,
27837         },
27838         {
27839                 "spoolss_AddPrinterDriver",
27840                 sizeof(struct spoolss_AddPrinterDriver),
27841                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27842                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27843                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27844                 false,
27845         },
27846         {
27847                 "spoolss_EnumPrinterDrivers",
27848                 sizeof(struct spoolss_EnumPrinterDrivers),
27849                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27850                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27851                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27852                 false,
27853         },
27854         {
27855                 "spoolss_GetPrinterDriver",
27856                 sizeof(struct spoolss_GetPrinterDriver),
27857                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27858                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27859                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27860                 false,
27861         },
27862         {
27863                 "spoolss_GetPrinterDriverDirectory",
27864                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27865                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27866                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27867                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27868                 false,
27869         },
27870         {
27871                 "spoolss_DeletePrinterDriver",
27872                 sizeof(struct spoolss_DeletePrinterDriver),
27873                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27874                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27875                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27876                 false,
27877         },
27878         {
27879                 "spoolss_AddPrintProcessor",
27880                 sizeof(struct spoolss_AddPrintProcessor),
27881                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27882                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27883                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27884                 false,
27885         },
27886         {
27887                 "spoolss_EnumPrintProcessors",
27888                 sizeof(struct spoolss_EnumPrintProcessors),
27889                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27890                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27891                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27892                 false,
27893         },
27894         {
27895                 "spoolss_GetPrintProcessorDirectory",
27896                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27897                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27898                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27899                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27900                 false,
27901         },
27902         {
27903                 "spoolss_StartDocPrinter",
27904                 sizeof(struct spoolss_StartDocPrinter),
27905                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27906                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27907                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27908                 false,
27909         },
27910         {
27911                 "spoolss_StartPagePrinter",
27912                 sizeof(struct spoolss_StartPagePrinter),
27913                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27914                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27915                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27916                 false,
27917         },
27918         {
27919                 "spoolss_WritePrinter",
27920                 sizeof(struct spoolss_WritePrinter),
27921                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27922                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27923                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27924                 false,
27925         },
27926         {
27927                 "spoolss_EndPagePrinter",
27928                 sizeof(struct spoolss_EndPagePrinter),
27929                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27930                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27931                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27932                 false,
27933         },
27934         {
27935                 "spoolss_AbortPrinter",
27936                 sizeof(struct spoolss_AbortPrinter),
27937                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27938                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27939                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27940                 false,
27941         },
27942         {
27943                 "spoolss_ReadPrinter",
27944                 sizeof(struct spoolss_ReadPrinter),
27945                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27946                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27947                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27948                 false,
27949         },
27950         {
27951                 "spoolss_EndDocPrinter",
27952                 sizeof(struct spoolss_EndDocPrinter),
27953                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27954                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27955                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27956                 false,
27957         },
27958         {
27959                 "spoolss_AddJob",
27960                 sizeof(struct spoolss_AddJob),
27961                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27962                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27963                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27964                 false,
27965         },
27966         {
27967                 "spoolss_ScheduleJob",
27968                 sizeof(struct spoolss_ScheduleJob),
27969                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27970                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27971                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27972                 false,
27973         },
27974         {
27975                 "spoolss_GetPrinterData",
27976                 sizeof(struct spoolss_GetPrinterData),
27977                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27978                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27979                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27980                 false,
27981         },
27982         {
27983                 "spoolss_SetPrinterData",
27984                 sizeof(struct spoolss_SetPrinterData),
27985                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27986                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27987                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27988                 false,
27989         },
27990         {
27991                 "spoolss_WaitForPrinterChange",
27992                 sizeof(struct spoolss_WaitForPrinterChange),
27993                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27994                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27995                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27996                 false,
27997         },
27998         {
27999                 "spoolss_ClosePrinter",
28000                 sizeof(struct spoolss_ClosePrinter),
28001                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
28002                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
28003                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
28004                 false,
28005         },
28006         {
28007                 "spoolss_AddForm",
28008                 sizeof(struct spoolss_AddForm),
28009                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
28010                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
28011                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
28012                 false,
28013         },
28014         {
28015                 "spoolss_DeleteForm",
28016                 sizeof(struct spoolss_DeleteForm),
28017                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
28018                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
28019                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
28020                 false,
28021         },
28022         {
28023                 "spoolss_GetForm",
28024                 sizeof(struct spoolss_GetForm),
28025                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
28026                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
28027                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
28028                 false,
28029         },
28030         {
28031                 "spoolss_SetForm",
28032                 sizeof(struct spoolss_SetForm),
28033                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
28034                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
28035                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
28036                 false,
28037         },
28038         {
28039                 "spoolss_EnumForms",
28040                 sizeof(struct spoolss_EnumForms),
28041                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
28042                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
28043                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
28044                 false,
28045         },
28046         {
28047                 "spoolss_EnumPorts",
28048                 sizeof(struct spoolss_EnumPorts),
28049                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
28050                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
28051                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
28052                 false,
28053         },
28054         {
28055                 "spoolss_EnumMonitors",
28056                 sizeof(struct spoolss_EnumMonitors),
28057                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
28058                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
28059                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
28060                 false,
28061         },
28062         {
28063                 "spoolss_AddPort",
28064                 sizeof(struct spoolss_AddPort),
28065                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
28066                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
28067                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
28068                 false,
28069         },
28070         {
28071                 "spoolss_ConfigurePort",
28072                 sizeof(struct spoolss_ConfigurePort),
28073                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
28074                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
28075                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
28076                 false,
28077         },
28078         {
28079                 "spoolss_DeletePort",
28080                 sizeof(struct spoolss_DeletePort),
28081                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
28082                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
28083                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
28084                 false,
28085         },
28086         {
28087                 "spoolss_CreatePrinterIC",
28088                 sizeof(struct spoolss_CreatePrinterIC),
28089                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
28090                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
28091                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
28092                 false,
28093         },
28094         {
28095                 "spoolss_PlayGDIScriptOnPrinterIC",
28096                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
28097                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
28098                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
28099                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
28100                 false,
28101         },
28102         {
28103                 "spoolss_DeletePrinterIC",
28104                 sizeof(struct spoolss_DeletePrinterIC),
28105                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
28106                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
28107                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
28108                 false,
28109         },
28110         {
28111                 "spoolss_AddPrinterConnection",
28112                 sizeof(struct spoolss_AddPrinterConnection),
28113                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
28114                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
28115                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
28116                 false,
28117         },
28118         {
28119                 "spoolss_DeletePrinterConnection",
28120                 sizeof(struct spoolss_DeletePrinterConnection),
28121                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
28122                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
28123                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
28124                 false,
28125         },
28126         {
28127                 "spoolss_PrinterMessageBox",
28128                 sizeof(struct spoolss_PrinterMessageBox),
28129                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
28130                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
28131                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
28132                 false,
28133         },
28134         {
28135                 "spoolss_AddMonitor",
28136                 sizeof(struct spoolss_AddMonitor),
28137                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
28138                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
28139                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
28140                 false,
28141         },
28142         {
28143                 "spoolss_DeleteMonitor",
28144                 sizeof(struct spoolss_DeleteMonitor),
28145                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
28146                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
28147                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
28148                 false,
28149         },
28150         {
28151                 "spoolss_DeletePrintProcessor",
28152                 sizeof(struct spoolss_DeletePrintProcessor),
28153                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
28154                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
28155                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
28156                 false,
28157         },
28158         {
28159                 "spoolss_AddPrintProvidor",
28160                 sizeof(struct spoolss_AddPrintProvidor),
28161                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
28162                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
28163                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
28164                 false,
28165         },
28166         {
28167                 "spoolss_DeletePrintProvidor",
28168                 sizeof(struct spoolss_DeletePrintProvidor),
28169                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
28170                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
28171                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
28172                 false,
28173         },
28174         {
28175                 "spoolss_EnumPrintProcDataTypes",
28176                 sizeof(struct spoolss_EnumPrintProcDataTypes),
28177                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
28178                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
28179                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
28180                 false,
28181         },
28182         {
28183                 "spoolss_ResetPrinter",
28184                 sizeof(struct spoolss_ResetPrinter),
28185                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
28186                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
28187                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
28188                 false,
28189         },
28190         {
28191                 "spoolss_GetPrinterDriver2",
28192                 sizeof(struct spoolss_GetPrinterDriver2),
28193                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
28194                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
28195                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
28196                 false,
28197         },
28198         {
28199                 "spoolss_FindFirstPrinterChangeNotification",
28200                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
28201                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
28202                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
28203                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
28204                 false,
28205         },
28206         {
28207                 "spoolss_FindNextPrinterChangeNotification",
28208                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
28209                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
28210                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
28211                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
28212                 false,
28213         },
28214         {
28215                 "spoolss_FindClosePrinterNotify",
28216                 sizeof(struct spoolss_FindClosePrinterNotify),
28217                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
28218                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
28219                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
28220                 false,
28221         },
28222         {
28223                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
28224                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
28225                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28226                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28227                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28228                 false,
28229         },
28230         {
28231                 "spoolss_ReplyOpenPrinter",
28232                 sizeof(struct spoolss_ReplyOpenPrinter),
28233                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
28234                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
28235                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
28236                 false,
28237         },
28238         {
28239                 "spoolss_RouterReplyPrinter",
28240                 sizeof(struct spoolss_RouterReplyPrinter),
28241                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
28242                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
28243                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
28244                 false,
28245         },
28246         {
28247                 "spoolss_ReplyClosePrinter",
28248                 sizeof(struct spoolss_ReplyClosePrinter),
28249                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
28250                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
28251                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
28252                 false,
28253         },
28254         {
28255                 "spoolss_AddPortEx",
28256                 sizeof(struct spoolss_AddPortEx),
28257                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
28258                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
28259                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
28260                 false,
28261         },
28262         {
28263                 "spoolss_RouterFindFirstPrinterChangeNotification",
28264                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
28265                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
28266                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
28267                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
28268                 false,
28269         },
28270         {
28271                 "spoolss_SpoolerInit",
28272                 sizeof(struct spoolss_SpoolerInit),
28273                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
28274                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
28275                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
28276                 false,
28277         },
28278         {
28279                 "spoolss_ResetPrinterEx",
28280                 sizeof(struct spoolss_ResetPrinterEx),
28281                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
28282                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
28283                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
28284                 false,
28285         },
28286         {
28287                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
28288                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
28289                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28290                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28291                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28292                 false,
28293         },
28294         {
28295                 "spoolss_RouterReplyPrinterEx",
28296                 sizeof(struct spoolss_RouterReplyPrinterEx),
28297                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
28298                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
28299                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
28300                 false,
28301         },
28302         {
28303                 "spoolss_RouterRefreshPrinterChangeNotify",
28304                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
28305                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
28306                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
28307                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
28308                 false,
28309         },
28310         {
28311                 "spoolss_44",
28312                 sizeof(struct spoolss_44),
28313                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
28314                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
28315                 (ndr_print_function_t) ndr_print_spoolss_44,
28316                 false,
28317         },
28318         {
28319                 "spoolss_OpenPrinterEx",
28320                 sizeof(struct spoolss_OpenPrinterEx),
28321                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
28322                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
28323                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
28324                 false,
28325         },
28326         {
28327                 "spoolss_AddPrinterEx",
28328                 sizeof(struct spoolss_AddPrinterEx),
28329                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
28330                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
28331                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
28332                 false,
28333         },
28334         {
28335                 "spoolss_47",
28336                 sizeof(struct spoolss_47),
28337                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
28338                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
28339                 (ndr_print_function_t) ndr_print_spoolss_47,
28340                 false,
28341         },
28342         {
28343                 "spoolss_EnumPrinterData",
28344                 sizeof(struct spoolss_EnumPrinterData),
28345                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
28346                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
28347                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
28348                 false,
28349         },
28350         {
28351                 "spoolss_DeletePrinterData",
28352                 sizeof(struct spoolss_DeletePrinterData),
28353                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
28354                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
28355                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
28356                 false,
28357         },
28358         {
28359                 "spoolss_4a",
28360                 sizeof(struct spoolss_4a),
28361                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
28362                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
28363                 (ndr_print_function_t) ndr_print_spoolss_4a,
28364                 false,
28365         },
28366         {
28367                 "spoolss_4b",
28368                 sizeof(struct spoolss_4b),
28369                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
28370                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
28371                 (ndr_print_function_t) ndr_print_spoolss_4b,
28372                 false,
28373         },
28374         {
28375                 "spoolss_4c",
28376                 sizeof(struct spoolss_4c),
28377                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
28378                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
28379                 (ndr_print_function_t) ndr_print_spoolss_4c,
28380                 false,
28381         },
28382         {
28383                 "spoolss_SetPrinterDataEx",
28384                 sizeof(struct spoolss_SetPrinterDataEx),
28385                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
28386                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
28387                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
28388                 false,
28389         },
28390         {
28391                 "spoolss_GetPrinterDataEx",
28392                 sizeof(struct spoolss_GetPrinterDataEx),
28393                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
28394                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
28395                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
28396                 false,
28397         },
28398         {
28399                 "spoolss_EnumPrinterDataEx",
28400                 sizeof(struct spoolss_EnumPrinterDataEx),
28401                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
28402                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
28403                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
28404                 false,
28405         },
28406         {
28407                 "spoolss_EnumPrinterKey",
28408                 sizeof(struct spoolss_EnumPrinterKey),
28409                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
28410                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
28411                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
28412                 false,
28413         },
28414         {
28415                 "spoolss_DeletePrinterDataEx",
28416                 sizeof(struct spoolss_DeletePrinterDataEx),
28417                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
28418                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
28419                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
28420                 false,
28421         },
28422         {
28423                 "spoolss_DeletePrinterKey",
28424                 sizeof(struct spoolss_DeletePrinterKey),
28425                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
28426                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
28427                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
28428                 false,
28429         },
28430         {
28431                 "spoolss_53",
28432                 sizeof(struct spoolss_53),
28433                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
28434                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
28435                 (ndr_print_function_t) ndr_print_spoolss_53,
28436                 false,
28437         },
28438         {
28439                 "spoolss_DeletePrinterDriverEx",
28440                 sizeof(struct spoolss_DeletePrinterDriverEx),
28441                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
28442                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
28443                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
28444                 false,
28445         },
28446         {
28447                 "spoolss_55",
28448                 sizeof(struct spoolss_55),
28449                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
28450                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
28451                 (ndr_print_function_t) ndr_print_spoolss_55,
28452                 false,
28453         },
28454         {
28455                 "spoolss_56",
28456                 sizeof(struct spoolss_56),
28457                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
28458                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
28459                 (ndr_print_function_t) ndr_print_spoolss_56,
28460                 false,
28461         },
28462         {
28463                 "spoolss_57",
28464                 sizeof(struct spoolss_57),
28465                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
28466                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
28467                 (ndr_print_function_t) ndr_print_spoolss_57,
28468                 false,
28469         },
28470         {
28471                 "spoolss_XcvData",
28472                 sizeof(struct spoolss_XcvData),
28473                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
28474                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
28475                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
28476                 false,
28477         },
28478         {
28479                 "spoolss_AddPrinterDriverEx",
28480                 sizeof(struct spoolss_AddPrinterDriverEx),
28481                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28482                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28483                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28484                 false,
28485         },
28486         {
28487                 "spoolss_5a",
28488                 sizeof(struct spoolss_5a),
28489                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28490                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28491                 (ndr_print_function_t) ndr_print_spoolss_5a,
28492                 false,
28493         },
28494         {
28495                 "spoolss_5b",
28496                 sizeof(struct spoolss_5b),
28497                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28498                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28499                 (ndr_print_function_t) ndr_print_spoolss_5b,
28500                 false,
28501         },
28502         {
28503                 "spoolss_5c",
28504                 sizeof(struct spoolss_5c),
28505                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
28506                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
28507                 (ndr_print_function_t) ndr_print_spoolss_5c,
28508                 false,
28509         },
28510         {
28511                 "spoolss_5d",
28512                 sizeof(struct spoolss_5d),
28513                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
28514                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
28515                 (ndr_print_function_t) ndr_print_spoolss_5d,
28516                 false,
28517         },
28518         {
28519                 "spoolss_5e",
28520                 sizeof(struct spoolss_5e),
28521                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
28522                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28523                 (ndr_print_function_t) ndr_print_spoolss_5e,
28524                 false,
28525         },
28526         {
28527                 "spoolss_5f",
28528                 sizeof(struct spoolss_5f),
28529                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28530                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28531                 (ndr_print_function_t) ndr_print_spoolss_5f,
28532                 false,
28533         },
28534         { NULL, 0, NULL, NULL, NULL, false }
28535 };
28536
28537 static const char * const spoolss_endpoint_strings[] = {
28538         "ncacn_np:[\\pipe\\spoolss]",
28539 };
28540
28541 static const struct ndr_interface_string_array spoolss_endpoints = {
28542         .count  = 1,
28543         .names  = spoolss_endpoint_strings
28544 };
28545
28546 static const char * const spoolss_authservice_strings[] = {
28547         "host",
28548 };
28549
28550 static const struct ndr_interface_string_array spoolss_authservices = {
28551         .count  = 1,
28552         .names  = spoolss_authservice_strings
28553 };
28554
28555
28556 const struct ndr_interface_table ndr_table_spoolss = {
28557         .name           = "spoolss",
28558         .syntax_id      = {
28559                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28560                 NDR_SPOOLSS_VERSION
28561         },
28562         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28563         .num_calls      = 96,
28564         .calls          = spoolss_calls,
28565         .endpoints      = &spoolss_endpoints,
28566         .authservices   = &spoolss_authservices
28567 };
28568