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 _PUBLIC_ void ndr_print_spoolss_StringArray2(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray2 *r)
7425 {
7426         ndr_print_struct(ndr, name, "spoolss_StringArray2");
7427         ndr->depth++;
7428         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray2(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
7429         ndr_print_string_array(ndr, "string", r->string);
7430         ndr->depth--;
7431 }
7432
7433 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7434 {
7435         if (ndr_flags & NDR_SCALARS) {
7436                 NDR_CHECK(ndr_push_align(ndr, 4));
7437                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7438         }
7439         if (ndr_flags & NDR_BUFFERS) {
7440                 if (r->driver_name) {
7441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7445                 }
7446         }
7447         return NDR_ERR_SUCCESS;
7448 }
7449
7450 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7451 {
7452         uint32_t _ptr_driver_name;
7453         TALLOC_CTX *_mem_save_driver_name_0;
7454         if (ndr_flags & NDR_SCALARS) {
7455                 NDR_CHECK(ndr_pull_align(ndr, 4));
7456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7457                 if (_ptr_driver_name) {
7458                         NDR_PULL_ALLOC(ndr, r->driver_name);
7459                 } else {
7460                         r->driver_name = NULL;
7461                 }
7462         }
7463         if (ndr_flags & NDR_BUFFERS) {
7464                 if (r->driver_name) {
7465                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7466                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7467                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7468                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7469                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7470                                 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));
7471                         }
7472                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7473                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7474                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7475                 }
7476         }
7477         return NDR_ERR_SUCCESS;
7478 }
7479
7480 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7481 {
7482         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7483         ndr->depth++;
7484         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7485         ndr->depth++;
7486         if (r->driver_name) {
7487                 ndr_print_string(ndr, "driver_name", r->driver_name);
7488         }
7489         ndr->depth--;
7490         ndr->depth--;
7491 }
7492
7493 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7494 {
7495         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7496         return NDR_ERR_SUCCESS;
7497 }
7498
7499 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7500 {
7501         uint32_t v;
7502         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7503         *r = v;
7504         return NDR_ERR_SUCCESS;
7505 }
7506
7507 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7508 {
7509         const char *val = NULL;
7510
7511         switch (r) {
7512                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7513                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7514                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7515                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7516         }
7517         ndr_print_enum(ndr, name, "ENUM", val, r);
7518 }
7519
7520 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7521 {
7522         if (ndr_flags & NDR_SCALARS) {
7523                 NDR_CHECK(ndr_push_align(ndr, 4));
7524                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7525                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7526                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7527                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7528                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7530         }
7531         if (ndr_flags & NDR_BUFFERS) {
7532                 if (r->driver_name) {
7533                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7534                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7535                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7536                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7537                 }
7538                 if (r->architecture) {
7539                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7540                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7541                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7542                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7543                 }
7544                 if (r->driver_path) {
7545                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7546                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7547                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7548                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7549                 }
7550                 if (r->data_file) {
7551                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7552                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7553                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7554                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7555                 }
7556                 if (r->config_file) {
7557                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7558                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7559                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7560                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7561                 }
7562         }
7563         return NDR_ERR_SUCCESS;
7564 }
7565
7566 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7567 {
7568         uint32_t _ptr_driver_name;
7569         TALLOC_CTX *_mem_save_driver_name_0;
7570         uint32_t _ptr_architecture;
7571         TALLOC_CTX *_mem_save_architecture_0;
7572         uint32_t _ptr_driver_path;
7573         TALLOC_CTX *_mem_save_driver_path_0;
7574         uint32_t _ptr_data_file;
7575         TALLOC_CTX *_mem_save_data_file_0;
7576         uint32_t _ptr_config_file;
7577         TALLOC_CTX *_mem_save_config_file_0;
7578         if (ndr_flags & NDR_SCALARS) {
7579                 NDR_CHECK(ndr_pull_align(ndr, 4));
7580                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7582                 if (_ptr_driver_name) {
7583                         NDR_PULL_ALLOC(ndr, r->driver_name);
7584                 } else {
7585                         r->driver_name = NULL;
7586                 }
7587                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7588                 if (_ptr_architecture) {
7589                         NDR_PULL_ALLOC(ndr, r->architecture);
7590                 } else {
7591                         r->architecture = NULL;
7592                 }
7593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7594                 if (_ptr_driver_path) {
7595                         NDR_PULL_ALLOC(ndr, r->driver_path);
7596                 } else {
7597                         r->driver_path = NULL;
7598                 }
7599                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7600                 if (_ptr_data_file) {
7601                         NDR_PULL_ALLOC(ndr, r->data_file);
7602                 } else {
7603                         r->data_file = NULL;
7604                 }
7605                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7606                 if (_ptr_config_file) {
7607                         NDR_PULL_ALLOC(ndr, r->config_file);
7608                 } else {
7609                         r->config_file = NULL;
7610                 }
7611         }
7612         if (ndr_flags & NDR_BUFFERS) {
7613                 if (r->driver_name) {
7614                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7615                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7616                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7617                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7618                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7619                                 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));
7620                         }
7621                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7622                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7623                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7624                 }
7625                 if (r->architecture) {
7626                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7627                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7628                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7629                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7630                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7631                                 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));
7632                         }
7633                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7634                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7635                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7636                 }
7637                 if (r->driver_path) {
7638                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7639                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7640                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7641                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7642                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7643                                 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));
7644                         }
7645                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7646                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7647                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7648                 }
7649                 if (r->data_file) {
7650                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7651                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7652                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7653                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7654                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7655                                 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));
7656                         }
7657                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7658                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7659                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7660                 }
7661                 if (r->config_file) {
7662                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7663                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7664                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7665                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7666                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7667                                 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));
7668                         }
7669                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7670                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7671                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7672                 }
7673         }
7674         return NDR_ERR_SUCCESS;
7675 }
7676
7677 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7678 {
7679         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7680         ndr->depth++;
7681         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7682         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7683         ndr->depth++;
7684         if (r->driver_name) {
7685                 ndr_print_string(ndr, "driver_name", r->driver_name);
7686         }
7687         ndr->depth--;
7688         ndr_print_ptr(ndr, "architecture", r->architecture);
7689         ndr->depth++;
7690         if (r->architecture) {
7691                 ndr_print_string(ndr, "architecture", r->architecture);
7692         }
7693         ndr->depth--;
7694         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7695         ndr->depth++;
7696         if (r->driver_path) {
7697                 ndr_print_string(ndr, "driver_path", r->driver_path);
7698         }
7699         ndr->depth--;
7700         ndr_print_ptr(ndr, "data_file", r->data_file);
7701         ndr->depth++;
7702         if (r->data_file) {
7703                 ndr_print_string(ndr, "data_file", r->data_file);
7704         }
7705         ndr->depth--;
7706         ndr_print_ptr(ndr, "config_file", r->config_file);
7707         ndr->depth++;
7708         if (r->config_file) {
7709                 ndr_print_string(ndr, "config_file", r->config_file);
7710         }
7711         ndr->depth--;
7712         ndr->depth--;
7713 }
7714
7715 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7716 {
7717         if (ndr_flags & NDR_SCALARS) {
7718                 NDR_CHECK(ndr_push_align(ndr, 4));
7719                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7720                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7721                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7723                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7725                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7727                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7729                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7730         }
7731         if (ndr_flags & NDR_BUFFERS) {
7732                 if (r->driver_name) {
7733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7737                 }
7738                 if (r->architecture) {
7739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7743                 }
7744                 if (r->driver_path) {
7745                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7748                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7749                 }
7750                 if (r->data_file) {
7751                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7752                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7754                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7755                 }
7756                 if (r->config_file) {
7757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7759                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7760                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7761                 }
7762                 if (r->help_file) {
7763                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7766                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7767                 }
7768                 if (r->monitor_name) {
7769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7771                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7772                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7773                 }
7774                 if (r->default_datatype) {
7775                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7776                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7777                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7778                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7779                 }
7780                 if (r->dependent_files) {
7781                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7782                 }
7783         }
7784         return NDR_ERR_SUCCESS;
7785 }
7786
7787 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7788 {
7789         uint32_t _ptr_driver_name;
7790         TALLOC_CTX *_mem_save_driver_name_0;
7791         uint32_t _ptr_architecture;
7792         TALLOC_CTX *_mem_save_architecture_0;
7793         uint32_t _ptr_driver_path;
7794         TALLOC_CTX *_mem_save_driver_path_0;
7795         uint32_t _ptr_data_file;
7796         TALLOC_CTX *_mem_save_data_file_0;
7797         uint32_t _ptr_config_file;
7798         TALLOC_CTX *_mem_save_config_file_0;
7799         uint32_t _ptr_help_file;
7800         TALLOC_CTX *_mem_save_help_file_0;
7801         uint32_t _ptr_monitor_name;
7802         TALLOC_CTX *_mem_save_monitor_name_0;
7803         uint32_t _ptr_default_datatype;
7804         TALLOC_CTX *_mem_save_default_datatype_0;
7805         uint32_t _ptr_dependent_files;
7806         TALLOC_CTX *_mem_save_dependent_files_0;
7807         if (ndr_flags & NDR_SCALARS) {
7808                 NDR_CHECK(ndr_pull_align(ndr, 4));
7809                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7810                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7811                 if (_ptr_driver_name) {
7812                         NDR_PULL_ALLOC(ndr, r->driver_name);
7813                 } else {
7814                         r->driver_name = NULL;
7815                 }
7816                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7817                 if (_ptr_architecture) {
7818                         NDR_PULL_ALLOC(ndr, r->architecture);
7819                 } else {
7820                         r->architecture = NULL;
7821                 }
7822                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7823                 if (_ptr_driver_path) {
7824                         NDR_PULL_ALLOC(ndr, r->driver_path);
7825                 } else {
7826                         r->driver_path = NULL;
7827                 }
7828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7829                 if (_ptr_data_file) {
7830                         NDR_PULL_ALLOC(ndr, r->data_file);
7831                 } else {
7832                         r->data_file = NULL;
7833                 }
7834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7835                 if (_ptr_config_file) {
7836                         NDR_PULL_ALLOC(ndr, r->config_file);
7837                 } else {
7838                         r->config_file = NULL;
7839                 }
7840                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7841                 if (_ptr_help_file) {
7842                         NDR_PULL_ALLOC(ndr, r->help_file);
7843                 } else {
7844                         r->help_file = NULL;
7845                 }
7846                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7847                 if (_ptr_monitor_name) {
7848                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7849                 } else {
7850                         r->monitor_name = NULL;
7851                 }
7852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7853                 if (_ptr_default_datatype) {
7854                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7855                 } else {
7856                         r->default_datatype = NULL;
7857                 }
7858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7859                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7860                 if (_ptr_dependent_files) {
7861                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7862                 } else {
7863                         r->dependent_files = NULL;
7864                 }
7865         }
7866         if (ndr_flags & NDR_BUFFERS) {
7867                 if (r->driver_name) {
7868                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7869                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7870                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7871                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7872                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7873                                 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));
7874                         }
7875                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7876                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7877                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7878                 }
7879                 if (r->architecture) {
7880                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7881                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7882                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7883                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7884                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7885                                 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));
7886                         }
7887                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7888                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7889                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7890                 }
7891                 if (r->driver_path) {
7892                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7893                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7894                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7895                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7896                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7897                                 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));
7898                         }
7899                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7900                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7901                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7902                 }
7903                 if (r->data_file) {
7904                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7905                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7906                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7907                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7908                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7909                                 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));
7910                         }
7911                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7912                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7914                 }
7915                 if (r->config_file) {
7916                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7917                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7918                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7919                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7920                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7921                                 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));
7922                         }
7923                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7924                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7925                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7926                 }
7927                 if (r->help_file) {
7928                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7929                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7930                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7931                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7932                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7933                                 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));
7934                         }
7935                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7936                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7937                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7938                 }
7939                 if (r->monitor_name) {
7940                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7941                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7942                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7943                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7944                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7945                                 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));
7946                         }
7947                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7948                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7949                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7950                 }
7951                 if (r->default_datatype) {
7952                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7953                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7954                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7955                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7956                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7957                                 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));
7958                         }
7959                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7960                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7961                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7962                 }
7963                 if (r->dependent_files) {
7964                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7965                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7966                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7967                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7968                 }
7969         }
7970         return NDR_ERR_SUCCESS;
7971 }
7972
7973 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7974 {
7975         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7976         ndr->depth++;
7977         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7978         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7979         ndr->depth++;
7980         if (r->driver_name) {
7981                 ndr_print_string(ndr, "driver_name", r->driver_name);
7982         }
7983         ndr->depth--;
7984         ndr_print_ptr(ndr, "architecture", r->architecture);
7985         ndr->depth++;
7986         if (r->architecture) {
7987                 ndr_print_string(ndr, "architecture", r->architecture);
7988         }
7989         ndr->depth--;
7990         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7991         ndr->depth++;
7992         if (r->driver_path) {
7993                 ndr_print_string(ndr, "driver_path", r->driver_path);
7994         }
7995         ndr->depth--;
7996         ndr_print_ptr(ndr, "data_file", r->data_file);
7997         ndr->depth++;
7998         if (r->data_file) {
7999                 ndr_print_string(ndr, "data_file", r->data_file);
8000         }
8001         ndr->depth--;
8002         ndr_print_ptr(ndr, "config_file", r->config_file);
8003         ndr->depth++;
8004         if (r->config_file) {
8005                 ndr_print_string(ndr, "config_file", r->config_file);
8006         }
8007         ndr->depth--;
8008         ndr_print_ptr(ndr, "help_file", r->help_file);
8009         ndr->depth++;
8010         if (r->help_file) {
8011                 ndr_print_string(ndr, "help_file", r->help_file);
8012         }
8013         ndr->depth--;
8014         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8015         ndr->depth++;
8016         if (r->monitor_name) {
8017                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8018         }
8019         ndr->depth--;
8020         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8021         ndr->depth++;
8022         if (r->default_datatype) {
8023                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8024         }
8025         ndr->depth--;
8026         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);
8027         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8028         ndr->depth++;
8029         if (r->dependent_files) {
8030                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8031         }
8032         ndr->depth--;
8033         ndr->depth--;
8034 }
8035
8036 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8037 {
8038         if (ndr_flags & NDR_SCALARS) {
8039                 NDR_CHECK(ndr_push_align(ndr, 4));
8040                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8042                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8048                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8050                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8053         }
8054         if (ndr_flags & NDR_BUFFERS) {
8055                 if (r->driver_name) {
8056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8058                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8059                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8060                 }
8061                 if (r->architecture) {
8062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8064                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8065                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8066                 }
8067                 if (r->driver_path) {
8068                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8069                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8070                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8071                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8072                 }
8073                 if (r->data_file) {
8074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8078                 }
8079                 if (r->config_file) {
8080                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8081                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8082                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8083                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8084                 }
8085                 if (r->help_file) {
8086                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8087                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8088                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8089                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8090                 }
8091                 if (r->monitor_name) {
8092                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8093                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8094                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8095                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8096                 }
8097                 if (r->default_datatype) {
8098                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8101                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8102                 }
8103                 if (r->dependent_files) {
8104                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8105                 }
8106                 if (r->previous_names) {
8107                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8108                 }
8109         }
8110         return NDR_ERR_SUCCESS;
8111 }
8112
8113 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8114 {
8115         uint32_t _ptr_driver_name;
8116         TALLOC_CTX *_mem_save_driver_name_0;
8117         uint32_t _ptr_architecture;
8118         TALLOC_CTX *_mem_save_architecture_0;
8119         uint32_t _ptr_driver_path;
8120         TALLOC_CTX *_mem_save_driver_path_0;
8121         uint32_t _ptr_data_file;
8122         TALLOC_CTX *_mem_save_data_file_0;
8123         uint32_t _ptr_config_file;
8124         TALLOC_CTX *_mem_save_config_file_0;
8125         uint32_t _ptr_help_file;
8126         TALLOC_CTX *_mem_save_help_file_0;
8127         uint32_t _ptr_monitor_name;
8128         TALLOC_CTX *_mem_save_monitor_name_0;
8129         uint32_t _ptr_default_datatype;
8130         TALLOC_CTX *_mem_save_default_datatype_0;
8131         uint32_t _ptr_dependent_files;
8132         TALLOC_CTX *_mem_save_dependent_files_0;
8133         uint32_t _ptr_previous_names;
8134         TALLOC_CTX *_mem_save_previous_names_0;
8135         if (ndr_flags & NDR_SCALARS) {
8136                 NDR_CHECK(ndr_pull_align(ndr, 4));
8137                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8138                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8139                 if (_ptr_driver_name) {
8140                         NDR_PULL_ALLOC(ndr, r->driver_name);
8141                 } else {
8142                         r->driver_name = NULL;
8143                 }
8144                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8145                 if (_ptr_architecture) {
8146                         NDR_PULL_ALLOC(ndr, r->architecture);
8147                 } else {
8148                         r->architecture = NULL;
8149                 }
8150                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8151                 if (_ptr_driver_path) {
8152                         NDR_PULL_ALLOC(ndr, r->driver_path);
8153                 } else {
8154                         r->driver_path = NULL;
8155                 }
8156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8157                 if (_ptr_data_file) {
8158                         NDR_PULL_ALLOC(ndr, r->data_file);
8159                 } else {
8160                         r->data_file = NULL;
8161                 }
8162                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8163                 if (_ptr_config_file) {
8164                         NDR_PULL_ALLOC(ndr, r->config_file);
8165                 } else {
8166                         r->config_file = NULL;
8167                 }
8168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8169                 if (_ptr_help_file) {
8170                         NDR_PULL_ALLOC(ndr, r->help_file);
8171                 } else {
8172                         r->help_file = NULL;
8173                 }
8174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8175                 if (_ptr_monitor_name) {
8176                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8177                 } else {
8178                         r->monitor_name = NULL;
8179                 }
8180                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8181                 if (_ptr_default_datatype) {
8182                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8183                 } else {
8184                         r->default_datatype = NULL;
8185                 }
8186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8188                 if (_ptr_dependent_files) {
8189                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8190                 } else {
8191                         r->dependent_files = NULL;
8192                 }
8193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8195                 if (_ptr_previous_names) {
8196                         NDR_PULL_ALLOC(ndr, r->previous_names);
8197                 } else {
8198                         r->previous_names = NULL;
8199                 }
8200         }
8201         if (ndr_flags & NDR_BUFFERS) {
8202                 if (r->driver_name) {
8203                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8204                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8205                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8206                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8207                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8208                                 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));
8209                         }
8210                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8211                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8213                 }
8214                 if (r->architecture) {
8215                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8216                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8217                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8218                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8219                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8220                                 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));
8221                         }
8222                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8223                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8224                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8225                 }
8226                 if (r->driver_path) {
8227                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8228                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8229                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8230                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8231                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8232                                 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));
8233                         }
8234                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8235                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8236                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8237                 }
8238                 if (r->data_file) {
8239                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8240                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8241                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8242                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8243                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8244                                 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));
8245                         }
8246                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8247                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8248                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8249                 }
8250                 if (r->config_file) {
8251                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8252                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8253                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8254                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8255                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8256                                 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));
8257                         }
8258                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8259                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8260                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8261                 }
8262                 if (r->help_file) {
8263                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8264                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8265                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8266                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8267                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8268                                 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));
8269                         }
8270                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8271                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8272                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8273                 }
8274                 if (r->monitor_name) {
8275                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8276                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8277                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8278                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8279                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8280                                 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));
8281                         }
8282                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8283                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8284                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8285                 }
8286                 if (r->default_datatype) {
8287                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8288                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8289                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8290                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8291                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8292                                 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));
8293                         }
8294                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8295                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8296                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8297                 }
8298                 if (r->dependent_files) {
8299                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8300                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8301                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8302                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8303                 }
8304                 if (r->previous_names) {
8305                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8306                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8307                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8308                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8309                 }
8310         }
8311         return NDR_ERR_SUCCESS;
8312 }
8313
8314 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8315 {
8316         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8317         ndr->depth++;
8318         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8319         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8320         ndr->depth++;
8321         if (r->driver_name) {
8322                 ndr_print_string(ndr, "driver_name", r->driver_name);
8323         }
8324         ndr->depth--;
8325         ndr_print_ptr(ndr, "architecture", r->architecture);
8326         ndr->depth++;
8327         if (r->architecture) {
8328                 ndr_print_string(ndr, "architecture", r->architecture);
8329         }
8330         ndr->depth--;
8331         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8332         ndr->depth++;
8333         if (r->driver_path) {
8334                 ndr_print_string(ndr, "driver_path", r->driver_path);
8335         }
8336         ndr->depth--;
8337         ndr_print_ptr(ndr, "data_file", r->data_file);
8338         ndr->depth++;
8339         if (r->data_file) {
8340                 ndr_print_string(ndr, "data_file", r->data_file);
8341         }
8342         ndr->depth--;
8343         ndr_print_ptr(ndr, "config_file", r->config_file);
8344         ndr->depth++;
8345         if (r->config_file) {
8346                 ndr_print_string(ndr, "config_file", r->config_file);
8347         }
8348         ndr->depth--;
8349         ndr_print_ptr(ndr, "help_file", r->help_file);
8350         ndr->depth++;
8351         if (r->help_file) {
8352                 ndr_print_string(ndr, "help_file", r->help_file);
8353         }
8354         ndr->depth--;
8355         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8356         ndr->depth++;
8357         if (r->monitor_name) {
8358                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8359         }
8360         ndr->depth--;
8361         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8362         ndr->depth++;
8363         if (r->default_datatype) {
8364                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8365         }
8366         ndr->depth--;
8367         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);
8368         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8369         ndr->depth++;
8370         if (r->dependent_files) {
8371                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8372         }
8373         ndr->depth--;
8374         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);
8375         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8376         ndr->depth++;
8377         if (r->previous_names) {
8378                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8379         }
8380         ndr->depth--;
8381         ndr->depth--;
8382 }
8383
8384 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8385 {
8386         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8387         return NDR_ERR_SUCCESS;
8388 }
8389
8390 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8391 {
8392         uint32_t v;
8393         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8394         *r = v;
8395         return NDR_ERR_SUCCESS;
8396 }
8397
8398 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
8399 {
8400         ndr_print_uint32(ndr, name, r);
8401         ndr->depth++;
8402         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
8403         ndr->depth--;
8404 }
8405
8406 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8407 {
8408         if (ndr_flags & NDR_SCALARS) {
8409                 NDR_CHECK(ndr_push_align(ndr, 8));
8410                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8412                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8414                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8415                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8417                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8420                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8422                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8423                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8424                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8427                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8429         }
8430         if (ndr_flags & NDR_BUFFERS) {
8431                 if (r->driver_name) {
8432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8435                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8436                 }
8437                 if (r->architecture) {
8438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8441                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8442                 }
8443                 if (r->driver_path) {
8444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8447                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8448                 }
8449                 if (r->data_file) {
8450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8453                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8454                 }
8455                 if (r->config_file) {
8456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8459                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8460                 }
8461                 if (r->help_file) {
8462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8465                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8466                 }
8467                 if (r->monitor_name) {
8468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8471                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8472                 }
8473                 if (r->default_datatype) {
8474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8476                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8477                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8478                 }
8479                 if (r->dependent_files) {
8480                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8481                 }
8482                 if (r->previous_names) {
8483                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8484                 }
8485                 if (r->manufacturer_name) {
8486                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8487                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8488                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8489                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8490                 }
8491                 if (r->manufacturer_url) {
8492                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8493                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8494                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8495                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8496                 }
8497                 if (r->hardware_id) {
8498                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8499                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8501                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8502                 }
8503                 if (r->provider) {
8504                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8505                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8506                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8507                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8508                 }
8509         }
8510         return NDR_ERR_SUCCESS;
8511 }
8512
8513 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8514 {
8515         uint32_t _ptr_driver_name;
8516         TALLOC_CTX *_mem_save_driver_name_0;
8517         uint32_t _ptr_architecture;
8518         TALLOC_CTX *_mem_save_architecture_0;
8519         uint32_t _ptr_driver_path;
8520         TALLOC_CTX *_mem_save_driver_path_0;
8521         uint32_t _ptr_data_file;
8522         TALLOC_CTX *_mem_save_data_file_0;
8523         uint32_t _ptr_config_file;
8524         TALLOC_CTX *_mem_save_config_file_0;
8525         uint32_t _ptr_help_file;
8526         TALLOC_CTX *_mem_save_help_file_0;
8527         uint32_t _ptr_monitor_name;
8528         TALLOC_CTX *_mem_save_monitor_name_0;
8529         uint32_t _ptr_default_datatype;
8530         TALLOC_CTX *_mem_save_default_datatype_0;
8531         uint32_t _ptr_dependent_files;
8532         TALLOC_CTX *_mem_save_dependent_files_0;
8533         uint32_t _ptr_previous_names;
8534         TALLOC_CTX *_mem_save_previous_names_0;
8535         uint32_t _ptr_manufacturer_name;
8536         TALLOC_CTX *_mem_save_manufacturer_name_0;
8537         uint32_t _ptr_manufacturer_url;
8538         TALLOC_CTX *_mem_save_manufacturer_url_0;
8539         uint32_t _ptr_hardware_id;
8540         TALLOC_CTX *_mem_save_hardware_id_0;
8541         uint32_t _ptr_provider;
8542         TALLOC_CTX *_mem_save_provider_0;
8543         if (ndr_flags & NDR_SCALARS) {
8544                 NDR_CHECK(ndr_pull_align(ndr, 8));
8545                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8546                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8547                 if (_ptr_driver_name) {
8548                         NDR_PULL_ALLOC(ndr, r->driver_name);
8549                 } else {
8550                         r->driver_name = NULL;
8551                 }
8552                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8553                 if (_ptr_architecture) {
8554                         NDR_PULL_ALLOC(ndr, r->architecture);
8555                 } else {
8556                         r->architecture = NULL;
8557                 }
8558                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8559                 if (_ptr_driver_path) {
8560                         NDR_PULL_ALLOC(ndr, r->driver_path);
8561                 } else {
8562                         r->driver_path = NULL;
8563                 }
8564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8565                 if (_ptr_data_file) {
8566                         NDR_PULL_ALLOC(ndr, r->data_file);
8567                 } else {
8568                         r->data_file = NULL;
8569                 }
8570                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8571                 if (_ptr_config_file) {
8572                         NDR_PULL_ALLOC(ndr, r->config_file);
8573                 } else {
8574                         r->config_file = NULL;
8575                 }
8576                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8577                 if (_ptr_help_file) {
8578                         NDR_PULL_ALLOC(ndr, r->help_file);
8579                 } else {
8580                         r->help_file = NULL;
8581                 }
8582                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8583                 if (_ptr_monitor_name) {
8584                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8585                 } else {
8586                         r->monitor_name = NULL;
8587                 }
8588                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8589                 if (_ptr_default_datatype) {
8590                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8591                 } else {
8592                         r->default_datatype = NULL;
8593                 }
8594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8595                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8596                 if (_ptr_dependent_files) {
8597                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8598                 } else {
8599                         r->dependent_files = NULL;
8600                 }
8601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8602                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8603                 if (_ptr_previous_names) {
8604                         NDR_PULL_ALLOC(ndr, r->previous_names);
8605                 } else {
8606                         r->previous_names = NULL;
8607                 }
8608                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8609                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8610                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8611                 if (_ptr_manufacturer_name) {
8612                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8613                 } else {
8614                         r->manufacturer_name = NULL;
8615                 }
8616                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8617                 if (_ptr_manufacturer_url) {
8618                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8619                 } else {
8620                         r->manufacturer_url = NULL;
8621                 }
8622                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8623                 if (_ptr_hardware_id) {
8624                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8625                 } else {
8626                         r->hardware_id = NULL;
8627                 }
8628                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8629                 if (_ptr_provider) {
8630                         NDR_PULL_ALLOC(ndr, r->provider);
8631                 } else {
8632                         r->provider = NULL;
8633                 }
8634         }
8635         if (ndr_flags & NDR_BUFFERS) {
8636                 if (r->driver_name) {
8637                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8638                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8639                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8640                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8641                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8642                                 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));
8643                         }
8644                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8645                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8646                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8647                 }
8648                 if (r->architecture) {
8649                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8650                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8651                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8652                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8653                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8654                                 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));
8655                         }
8656                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8657                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8658                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8659                 }
8660                 if (r->driver_path) {
8661                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8662                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8663                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8664                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8665                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8666                                 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));
8667                         }
8668                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8669                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8670                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8671                 }
8672                 if (r->data_file) {
8673                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8674                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8675                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8676                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8677                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8678                                 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));
8679                         }
8680                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8681                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8682                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8683                 }
8684                 if (r->config_file) {
8685                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8686                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8687                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8688                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8689                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8690                                 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));
8691                         }
8692                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8693                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8694                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8695                 }
8696                 if (r->help_file) {
8697                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8698                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8699                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8700                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8701                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8702                                 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));
8703                         }
8704                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8705                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8706                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8707                 }
8708                 if (r->monitor_name) {
8709                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8710                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8711                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8712                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8713                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8714                                 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));
8715                         }
8716                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8717                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8718                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8719                 }
8720                 if (r->default_datatype) {
8721                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8722                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8723                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8724                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8725                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8726                                 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));
8727                         }
8728                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8729                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8730                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8731                 }
8732                 if (r->dependent_files) {
8733                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8734                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8735                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8736                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8737                 }
8738                 if (r->previous_names) {
8739                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8740                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8741                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8742                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8743                 }
8744                 if (r->manufacturer_name) {
8745                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8746                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8747                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8748                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8749                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8750                                 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));
8751                         }
8752                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8753                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8754                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8755                 }
8756                 if (r->manufacturer_url) {
8757                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8758                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8759                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8760                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8761                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8762                                 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));
8763                         }
8764                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8765                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8766                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8767                 }
8768                 if (r->hardware_id) {
8769                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8770                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8771                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8772                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8773                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8774                                 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));
8775                         }
8776                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8777                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8778                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8779                 }
8780                 if (r->provider) {
8781                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8782                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8783                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8784                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8785                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8786                                 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));
8787                         }
8788                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8789                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8790                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8791                 }
8792         }
8793         return NDR_ERR_SUCCESS;
8794 }
8795
8796 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8797 {
8798         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8799         ndr->depth++;
8800         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8801         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8802         ndr->depth++;
8803         if (r->driver_name) {
8804                 ndr_print_string(ndr, "driver_name", r->driver_name);
8805         }
8806         ndr->depth--;
8807         ndr_print_ptr(ndr, "architecture", r->architecture);
8808         ndr->depth++;
8809         if (r->architecture) {
8810                 ndr_print_string(ndr, "architecture", r->architecture);
8811         }
8812         ndr->depth--;
8813         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8814         ndr->depth++;
8815         if (r->driver_path) {
8816                 ndr_print_string(ndr, "driver_path", r->driver_path);
8817         }
8818         ndr->depth--;
8819         ndr_print_ptr(ndr, "data_file", r->data_file);
8820         ndr->depth++;
8821         if (r->data_file) {
8822                 ndr_print_string(ndr, "data_file", r->data_file);
8823         }
8824         ndr->depth--;
8825         ndr_print_ptr(ndr, "config_file", r->config_file);
8826         ndr->depth++;
8827         if (r->config_file) {
8828                 ndr_print_string(ndr, "config_file", r->config_file);
8829         }
8830         ndr->depth--;
8831         ndr_print_ptr(ndr, "help_file", r->help_file);
8832         ndr->depth++;
8833         if (r->help_file) {
8834                 ndr_print_string(ndr, "help_file", r->help_file);
8835         }
8836         ndr->depth--;
8837         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8838         ndr->depth++;
8839         if (r->monitor_name) {
8840                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8841         }
8842         ndr->depth--;
8843         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8844         ndr->depth++;
8845         if (r->default_datatype) {
8846                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8847         }
8848         ndr->depth--;
8849         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);
8850         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8851         ndr->depth++;
8852         if (r->dependent_files) {
8853                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8854         }
8855         ndr->depth--;
8856         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);
8857         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8858         ndr->depth++;
8859         if (r->previous_names) {
8860                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8861         }
8862         ndr->depth--;
8863         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8864         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8865         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8866         ndr->depth++;
8867         if (r->manufacturer_name) {
8868                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8869         }
8870         ndr->depth--;
8871         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8872         ndr->depth++;
8873         if (r->manufacturer_url) {
8874                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8875         }
8876         ndr->depth--;
8877         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8878         ndr->depth++;
8879         if (r->hardware_id) {
8880                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8881         }
8882         ndr->depth--;
8883         ndr_print_ptr(ndr, "provider", r->provider);
8884         ndr->depth++;
8885         if (r->provider) {
8886                 ndr_print_string(ndr, "provider", r->provider);
8887         }
8888         ndr->depth--;
8889         ndr->depth--;
8890 }
8891
8892 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8893 {
8894         if (ndr_flags & NDR_SCALARS) {
8895                 NDR_CHECK(ndr_push_align(ndr, 8));
8896                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8898                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8900                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8901                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8905                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8908                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8909                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8910                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8911                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8914                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8915                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8916                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8918                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8919                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8922                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8923                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8924                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8925         }
8926         if (ndr_flags & NDR_BUFFERS) {
8927                 if (r->driver_name) {
8928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8930                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8931                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8932                 }
8933                 if (r->architecture) {
8934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8936                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8937                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8938                 }
8939                 if (r->driver_path) {
8940                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8941                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8942                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8943                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8944                 }
8945                 if (r->data_file) {
8946                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8949                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8950                 }
8951                 if (r->config_file) {
8952                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8954                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8955                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8956                 }
8957                 if (r->help_file) {
8958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8960                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8961                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8962                 }
8963                 if (r->monitor_name) {
8964                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8966                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8967                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8968                 }
8969                 if (r->default_datatype) {
8970                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8972                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8973                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8974                 }
8975                 if (r->dependent_files) {
8976                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8977                 }
8978                 if (r->previous_names) {
8979                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8980                 }
8981                 if (r->manufacturer_name) {
8982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8985                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8986                 }
8987                 if (r->manufacturer_url) {
8988                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8989                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8991                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8992                 }
8993                 if (r->hardware_id) {
8994                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8997                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8998                 }
8999                 if (r->provider) {
9000                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9001                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
9003                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9004                 }
9005                 if (r->print_processor) {
9006                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9007                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9008                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9009                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9010                 }
9011                 if (r->vendor_setup) {
9012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, 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->vendor_setup, CH_UTF16)));
9015                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9016                 }
9017                 if (r->color_profiles) {
9018                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9019                 }
9020                 if (r->inf_path) {
9021                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9022                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9024                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9025                 }
9026                 if (r->core_driver_dependencies) {
9027                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9028                 }
9029         }
9030         return NDR_ERR_SUCCESS;
9031 }
9032
9033 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9034 {
9035         uint32_t _ptr_driver_name;
9036         TALLOC_CTX *_mem_save_driver_name_0;
9037         uint32_t _ptr_architecture;
9038         TALLOC_CTX *_mem_save_architecture_0;
9039         uint32_t _ptr_driver_path;
9040         TALLOC_CTX *_mem_save_driver_path_0;
9041         uint32_t _ptr_data_file;
9042         TALLOC_CTX *_mem_save_data_file_0;
9043         uint32_t _ptr_config_file;
9044         TALLOC_CTX *_mem_save_config_file_0;
9045         uint32_t _ptr_help_file;
9046         TALLOC_CTX *_mem_save_help_file_0;
9047         uint32_t _ptr_monitor_name;
9048         TALLOC_CTX *_mem_save_monitor_name_0;
9049         uint32_t _ptr_default_datatype;
9050         TALLOC_CTX *_mem_save_default_datatype_0;
9051         uint32_t _ptr_dependent_files;
9052         TALLOC_CTX *_mem_save_dependent_files_0;
9053         uint32_t _ptr_previous_names;
9054         TALLOC_CTX *_mem_save_previous_names_0;
9055         uint32_t _ptr_manufacturer_name;
9056         TALLOC_CTX *_mem_save_manufacturer_name_0;
9057         uint32_t _ptr_manufacturer_url;
9058         TALLOC_CTX *_mem_save_manufacturer_url_0;
9059         uint32_t _ptr_hardware_id;
9060         TALLOC_CTX *_mem_save_hardware_id_0;
9061         uint32_t _ptr_provider;
9062         TALLOC_CTX *_mem_save_provider_0;
9063         uint32_t _ptr_print_processor;
9064         TALLOC_CTX *_mem_save_print_processor_0;
9065         uint32_t _ptr_vendor_setup;
9066         TALLOC_CTX *_mem_save_vendor_setup_0;
9067         uint32_t _ptr_color_profiles;
9068         TALLOC_CTX *_mem_save_color_profiles_0;
9069         uint32_t _ptr_inf_path;
9070         TALLOC_CTX *_mem_save_inf_path_0;
9071         uint32_t _ptr_core_driver_dependencies;
9072         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9073         if (ndr_flags & NDR_SCALARS) {
9074                 NDR_CHECK(ndr_pull_align(ndr, 8));
9075                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9077                 if (_ptr_driver_name) {
9078                         NDR_PULL_ALLOC(ndr, r->driver_name);
9079                 } else {
9080                         r->driver_name = NULL;
9081                 }
9082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9083                 if (_ptr_architecture) {
9084                         NDR_PULL_ALLOC(ndr, r->architecture);
9085                 } else {
9086                         r->architecture = NULL;
9087                 }
9088                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9089                 if (_ptr_driver_path) {
9090                         NDR_PULL_ALLOC(ndr, r->driver_path);
9091                 } else {
9092                         r->driver_path = NULL;
9093                 }
9094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9095                 if (_ptr_data_file) {
9096                         NDR_PULL_ALLOC(ndr, r->data_file);
9097                 } else {
9098                         r->data_file = NULL;
9099                 }
9100                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9101                 if (_ptr_config_file) {
9102                         NDR_PULL_ALLOC(ndr, r->config_file);
9103                 } else {
9104                         r->config_file = NULL;
9105                 }
9106                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9107                 if (_ptr_help_file) {
9108                         NDR_PULL_ALLOC(ndr, r->help_file);
9109                 } else {
9110                         r->help_file = NULL;
9111                 }
9112                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9113                 if (_ptr_monitor_name) {
9114                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9115                 } else {
9116                         r->monitor_name = NULL;
9117                 }
9118                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9119                 if (_ptr_default_datatype) {
9120                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9121                 } else {
9122                         r->default_datatype = NULL;
9123                 }
9124                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9125                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9126                 if (_ptr_dependent_files) {
9127                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9128                 } else {
9129                         r->dependent_files = NULL;
9130                 }
9131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9132                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9133                 if (_ptr_previous_names) {
9134                         NDR_PULL_ALLOC(ndr, r->previous_names);
9135                 } else {
9136                         r->previous_names = NULL;
9137                 }
9138                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9139                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9140                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9141                 if (_ptr_manufacturer_name) {
9142                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9143                 } else {
9144                         r->manufacturer_name = NULL;
9145                 }
9146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9147                 if (_ptr_manufacturer_url) {
9148                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9149                 } else {
9150                         r->manufacturer_url = NULL;
9151                 }
9152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9153                 if (_ptr_hardware_id) {
9154                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9155                 } else {
9156                         r->hardware_id = NULL;
9157                 }
9158                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9159                 if (_ptr_provider) {
9160                         NDR_PULL_ALLOC(ndr, r->provider);
9161                 } else {
9162                         r->provider = NULL;
9163                 }
9164                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9165                 if (_ptr_print_processor) {
9166                         NDR_PULL_ALLOC(ndr, r->print_processor);
9167                 } else {
9168                         r->print_processor = NULL;
9169                 }
9170                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9171                 if (_ptr_vendor_setup) {
9172                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9173                 } else {
9174                         r->vendor_setup = NULL;
9175                 }
9176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9177                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9178                 if (_ptr_color_profiles) {
9179                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9180                 } else {
9181                         r->color_profiles = NULL;
9182                 }
9183                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9184                 if (_ptr_inf_path) {
9185                         NDR_PULL_ALLOC(ndr, r->inf_path);
9186                 } else {
9187                         r->inf_path = NULL;
9188                 }
9189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9191                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9192                 if (_ptr_core_driver_dependencies) {
9193                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9194                 } else {
9195                         r->core_driver_dependencies = NULL;
9196                 }
9197                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9198                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9199         }
9200         if (ndr_flags & NDR_BUFFERS) {
9201                 if (r->driver_name) {
9202                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9203                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9204                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9205                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9206                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9207                                 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));
9208                         }
9209                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9210                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9212                 }
9213                 if (r->architecture) {
9214                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9215                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9216                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9217                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9218                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9219                                 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));
9220                         }
9221                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9222                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9223                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9224                 }
9225                 if (r->driver_path) {
9226                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9227                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9228                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9229                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9230                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9231                                 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));
9232                         }
9233                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9234                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9235                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9236                 }
9237                 if (r->data_file) {
9238                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9239                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9240                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9241                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9242                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9243                                 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));
9244                         }
9245                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9246                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9247                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9248                 }
9249                 if (r->config_file) {
9250                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9251                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9252                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9253                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9254                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9255                                 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));
9256                         }
9257                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9258                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9259                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9260                 }
9261                 if (r->help_file) {
9262                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9263                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9264                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9265                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9266                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9267                                 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));
9268                         }
9269                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9270                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9271                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9272                 }
9273                 if (r->monitor_name) {
9274                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9275                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9276                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9277                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9278                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9279                                 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));
9280                         }
9281                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9282                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9284                 }
9285                 if (r->default_datatype) {
9286                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9287                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9288                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9289                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9290                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9291                                 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));
9292                         }
9293                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9294                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9296                 }
9297                 if (r->dependent_files) {
9298                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9299                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9300                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9301                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9302                 }
9303                 if (r->previous_names) {
9304                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9305                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9306                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9307                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9308                 }
9309                 if (r->manufacturer_name) {
9310                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9311                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9312                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9313                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9314                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9315                                 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));
9316                         }
9317                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9318                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9319                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9320                 }
9321                 if (r->manufacturer_url) {
9322                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9323                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9324                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9325                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9326                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9327                                 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));
9328                         }
9329                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9330                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9332                 }
9333                 if (r->hardware_id) {
9334                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9335                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9338                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9339                                 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));
9340                         }
9341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9344                 }
9345                 if (r->provider) {
9346                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9347                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9350                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9351                                 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));
9352                         }
9353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9356                 }
9357                 if (r->print_processor) {
9358                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9359                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9362                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9363                                 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));
9364                         }
9365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9368                 }
9369                 if (r->vendor_setup) {
9370                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9371                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9374                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9375                                 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));
9376                         }
9377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9380                 }
9381                 if (r->color_profiles) {
9382                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9383                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9384                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9385                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9386                 }
9387                 if (r->inf_path) {
9388                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9389                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9390                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9391                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9392                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9393                                 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));
9394                         }
9395                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9396                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9397                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9398                 }
9399                 if (r->core_driver_dependencies) {
9400                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9401                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9402                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9404                 }
9405         }
9406         return NDR_ERR_SUCCESS;
9407 }
9408
9409 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9410 {
9411         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9412         ndr->depth++;
9413         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9414         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9415         ndr->depth++;
9416         if (r->driver_name) {
9417                 ndr_print_string(ndr, "driver_name", r->driver_name);
9418         }
9419         ndr->depth--;
9420         ndr_print_ptr(ndr, "architecture", r->architecture);
9421         ndr->depth++;
9422         if (r->architecture) {
9423                 ndr_print_string(ndr, "architecture", r->architecture);
9424         }
9425         ndr->depth--;
9426         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9427         ndr->depth++;
9428         if (r->driver_path) {
9429                 ndr_print_string(ndr, "driver_path", r->driver_path);
9430         }
9431         ndr->depth--;
9432         ndr_print_ptr(ndr, "data_file", r->data_file);
9433         ndr->depth++;
9434         if (r->data_file) {
9435                 ndr_print_string(ndr, "data_file", r->data_file);
9436         }
9437         ndr->depth--;
9438         ndr_print_ptr(ndr, "config_file", r->config_file);
9439         ndr->depth++;
9440         if (r->config_file) {
9441                 ndr_print_string(ndr, "config_file", r->config_file);
9442         }
9443         ndr->depth--;
9444         ndr_print_ptr(ndr, "help_file", r->help_file);
9445         ndr->depth++;
9446         if (r->help_file) {
9447                 ndr_print_string(ndr, "help_file", r->help_file);
9448         }
9449         ndr->depth--;
9450         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9451         ndr->depth++;
9452         if (r->monitor_name) {
9453                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9454         }
9455         ndr->depth--;
9456         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9457         ndr->depth++;
9458         if (r->default_datatype) {
9459                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9460         }
9461         ndr->depth--;
9462         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);
9463         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9464         ndr->depth++;
9465         if (r->dependent_files) {
9466                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9467         }
9468         ndr->depth--;
9469         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);
9470         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9471         ndr->depth++;
9472         if (r->previous_names) {
9473                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9474         }
9475         ndr->depth--;
9476         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9477         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9478         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9479         ndr->depth++;
9480         if (r->manufacturer_name) {
9481                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9482         }
9483         ndr->depth--;
9484         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9485         ndr->depth++;
9486         if (r->manufacturer_url) {
9487                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9488         }
9489         ndr->depth--;
9490         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9491         ndr->depth++;
9492         if (r->hardware_id) {
9493                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9494         }
9495         ndr->depth--;
9496         ndr_print_ptr(ndr, "provider", r->provider);
9497         ndr->depth++;
9498         if (r->provider) {
9499                 ndr_print_string(ndr, "provider", r->provider);
9500         }
9501         ndr->depth--;
9502         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9503         ndr->depth++;
9504         if (r->print_processor) {
9505                 ndr_print_string(ndr, "print_processor", r->print_processor);
9506         }
9507         ndr->depth--;
9508         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9509         ndr->depth++;
9510         if (r->vendor_setup) {
9511                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9512         }
9513         ndr->depth--;
9514         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);
9515         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9516         ndr->depth++;
9517         if (r->color_profiles) {
9518                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9519         }
9520         ndr->depth--;
9521         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9522         ndr->depth++;
9523         if (r->inf_path) {
9524                 ndr_print_string(ndr, "inf_path", r->inf_path);
9525         }
9526         ndr->depth--;
9527         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9528         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);
9529         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9530         ndr->depth++;
9531         if (r->core_driver_dependencies) {
9532                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9533         }
9534         ndr->depth--;
9535         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9536         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9537         ndr->depth--;
9538 }
9539
9540 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9541 {
9542         if (ndr_flags & NDR_SCALARS) {
9543                 int level = ndr_push_get_switch_value(ndr, r);
9544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9545                 switch (level) {
9546                         case 1: {
9547                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9548                         break; }
9549
9550                         case 2: {
9551                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9552                         break; }
9553
9554                         case 3: {
9555                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9556                         break; }
9557
9558                         case 4: {
9559                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9560                         break; }
9561
9562                         case 6: {
9563                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9564                         break; }
9565
9566                         case 8: {
9567                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9568                         break; }
9569
9570                         default:
9571                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9572                 }
9573         }
9574         if (ndr_flags & NDR_BUFFERS) {
9575                 int level = ndr_push_get_switch_value(ndr, r);
9576                 switch (level) {
9577                         case 1:
9578                                 if (r->info1) {
9579                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9580                                 }
9581                         break;
9582
9583                         case 2:
9584                                 if (r->info2) {
9585                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9586                                 }
9587                         break;
9588
9589                         case 3:
9590                                 if (r->info3) {
9591                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9592                                 }
9593                         break;
9594
9595                         case 4:
9596                                 if (r->info4) {
9597                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9598                                 }
9599                         break;
9600
9601                         case 6:
9602                                 if (r->info6) {
9603                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9604                                 }
9605                         break;
9606
9607                         case 8:
9608                                 if (r->info8) {
9609                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9610                                 }
9611                         break;
9612
9613                         default:
9614                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9615                 }
9616         }
9617         return NDR_ERR_SUCCESS;
9618 }
9619
9620 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9621 {
9622         int level;
9623         uint32_t _level;
9624         TALLOC_CTX *_mem_save_info1_0;
9625         TALLOC_CTX *_mem_save_info2_0;
9626         TALLOC_CTX *_mem_save_info3_0;
9627         TALLOC_CTX *_mem_save_info4_0;
9628         TALLOC_CTX *_mem_save_info6_0;
9629         TALLOC_CTX *_mem_save_info8_0;
9630         level = ndr_pull_get_switch_value(ndr, r);
9631         if (ndr_flags & NDR_SCALARS) {
9632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9633                 if (_level != level) {
9634                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9635                 }
9636                 switch (level) {
9637                         case 1: {
9638                                 uint32_t _ptr_info1;
9639                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9640                                 if (_ptr_info1) {
9641                                         NDR_PULL_ALLOC(ndr, r->info1);
9642                                 } else {
9643                                         r->info1 = NULL;
9644                                 }
9645                         break; }
9646
9647                         case 2: {
9648                                 uint32_t _ptr_info2;
9649                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9650                                 if (_ptr_info2) {
9651                                         NDR_PULL_ALLOC(ndr, r->info2);
9652                                 } else {
9653                                         r->info2 = NULL;
9654                                 }
9655                         break; }
9656
9657                         case 3: {
9658                                 uint32_t _ptr_info3;
9659                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9660                                 if (_ptr_info3) {
9661                                         NDR_PULL_ALLOC(ndr, r->info3);
9662                                 } else {
9663                                         r->info3 = NULL;
9664                                 }
9665                         break; }
9666
9667                         case 4: {
9668                                 uint32_t _ptr_info4;
9669                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9670                                 if (_ptr_info4) {
9671                                         NDR_PULL_ALLOC(ndr, r->info4);
9672                                 } else {
9673                                         r->info4 = NULL;
9674                                 }
9675                         break; }
9676
9677                         case 6: {
9678                                 uint32_t _ptr_info6;
9679                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9680                                 if (_ptr_info6) {
9681                                         NDR_PULL_ALLOC(ndr, r->info6);
9682                                 } else {
9683                                         r->info6 = NULL;
9684                                 }
9685                         break; }
9686
9687                         case 8: {
9688                                 uint32_t _ptr_info8;
9689                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9690                                 if (_ptr_info8) {
9691                                         NDR_PULL_ALLOC(ndr, r->info8);
9692                                 } else {
9693                                         r->info8 = NULL;
9694                                 }
9695                         break; }
9696
9697                         default:
9698                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9699                 }
9700         }
9701         if (ndr_flags & NDR_BUFFERS) {
9702                 switch (level) {
9703                         case 1:
9704                                 if (r->info1) {
9705                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9706                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9707                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9708                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9709                                 }
9710                         break;
9711
9712                         case 2:
9713                                 if (r->info2) {
9714                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9715                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9716                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9717                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9718                                 }
9719                         break;
9720
9721                         case 3:
9722                                 if (r->info3) {
9723                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9724                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9725                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9726                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9727                                 }
9728                         break;
9729
9730                         case 4:
9731                                 if (r->info4) {
9732                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9733                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9734                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9735                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9736                                 }
9737                         break;
9738
9739                         case 6:
9740                                 if (r->info6) {
9741                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9742                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9743                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9744                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9745                                 }
9746                         break;
9747
9748                         case 8:
9749                                 if (r->info8) {
9750                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9751                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9752                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9753                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9754                                 }
9755                         break;
9756
9757                         default:
9758                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9759                 }
9760         }
9761         return NDR_ERR_SUCCESS;
9762 }
9763
9764 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9765 {
9766         int level;
9767         level = ndr_print_get_switch_value(ndr, r);
9768         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9769         switch (level) {
9770                 case 1:
9771                         ndr_print_ptr(ndr, "info1", r->info1);
9772                         ndr->depth++;
9773                         if (r->info1) {
9774                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9775                         }
9776                         ndr->depth--;
9777                 break;
9778
9779                 case 2:
9780                         ndr_print_ptr(ndr, "info2", r->info2);
9781                         ndr->depth++;
9782                         if (r->info2) {
9783                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9784                         }
9785                         ndr->depth--;
9786                 break;
9787
9788                 case 3:
9789                         ndr_print_ptr(ndr, "info3", r->info3);
9790                         ndr->depth++;
9791                         if (r->info3) {
9792                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9793                         }
9794                         ndr->depth--;
9795                 break;
9796
9797                 case 4:
9798                         ndr_print_ptr(ndr, "info4", r->info4);
9799                         ndr->depth++;
9800                         if (r->info4) {
9801                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9802                         }
9803                         ndr->depth--;
9804                 break;
9805
9806                 case 6:
9807                         ndr_print_ptr(ndr, "info6", r->info6);
9808                         ndr->depth++;
9809                         if (r->info6) {
9810                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9811                         }
9812                         ndr->depth--;
9813                 break;
9814
9815                 case 8:
9816                         ndr_print_ptr(ndr, "info8", r->info8);
9817                         ndr->depth++;
9818                         if (r->info8) {
9819                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9820                         }
9821                         ndr->depth--;
9822                 break;
9823
9824                 default:
9825                         ndr_print_bad_level(ndr, name, level);
9826         }
9827 }
9828
9829 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9830 {
9831         if (ndr_flags & NDR_SCALARS) {
9832                 NDR_CHECK(ndr_push_align(ndr, 4));
9833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9834                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9835                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9836         }
9837         if (ndr_flags & NDR_BUFFERS) {
9838                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9839         }
9840         return NDR_ERR_SUCCESS;
9841 }
9842
9843 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9844 {
9845         if (ndr_flags & NDR_SCALARS) {
9846                 NDR_CHECK(ndr_pull_align(ndr, 4));
9847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9848                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9849                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9850         }
9851         if (ndr_flags & NDR_BUFFERS) {
9852                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9853         }
9854         return NDR_ERR_SUCCESS;
9855 }
9856
9857 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9858 {
9859         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9860         ndr->depth++;
9861         ndr_print_uint32(ndr, "level", r->level);
9862         ndr_print_set_switch_value(ndr, &r->info, r->level);
9863         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9864         ndr->depth--;
9865 }
9866
9867 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9868 {
9869         if (ndr_flags & NDR_SCALARS) {
9870                 NDR_CHECK(ndr_push_align(ndr, 4));
9871                 {
9872                         uint32_t _flags_save_string = ndr->flags;
9873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9874                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9875                         ndr->flags = _flags_save_string;
9876                 }
9877         }
9878         if (ndr_flags & NDR_BUFFERS) {
9879                 {
9880                         uint32_t _flags_save_string = ndr->flags;
9881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9882                         if (r->driver_name) {
9883                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9884                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9885                         }
9886                         ndr->flags = _flags_save_string;
9887                 }
9888         }
9889         return NDR_ERR_SUCCESS;
9890 }
9891
9892 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9893 {
9894         uint32_t _ptr_driver_name;
9895         TALLOC_CTX *_mem_save_driver_name_0;
9896         if (ndr_flags & NDR_SCALARS) {
9897                 NDR_CHECK(ndr_pull_align(ndr, 4));
9898                 {
9899                         uint32_t _flags_save_string = ndr->flags;
9900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9901                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9902                         if (_ptr_driver_name) {
9903                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9905                         } else {
9906                                 r->driver_name = NULL;
9907                         }
9908                         ndr->flags = _flags_save_string;
9909                 }
9910         }
9911         if (ndr_flags & NDR_BUFFERS) {
9912                 {
9913                         uint32_t _flags_save_string = ndr->flags;
9914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9915                         if (r->driver_name) {
9916                                 uint32_t _relative_save_offset;
9917                                 _relative_save_offset = ndr->offset;
9918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9919                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9920                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9923                                 ndr->offset = _relative_save_offset;
9924                         }
9925                         ndr->flags = _flags_save_string;
9926                 }
9927         }
9928         return NDR_ERR_SUCCESS;
9929 }
9930
9931 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9932 {
9933         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9934         ndr->depth++;
9935         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9936         ndr->depth++;
9937         if (r->driver_name) {
9938                 ndr_print_string(ndr, "driver_name", r->driver_name);
9939         }
9940         ndr->depth--;
9941         ndr->depth--;
9942 }
9943
9944 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9945 {
9946         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9947 }
9948
9949 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9950 {
9951         if (ndr_flags & NDR_SCALARS) {
9952                 NDR_CHECK(ndr_push_align(ndr, 4));
9953                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9954                 {
9955                         uint32_t _flags_save_string = ndr->flags;
9956                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9957                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9958                         ndr->flags = _flags_save_string;
9959                 }
9960                 {
9961                         uint32_t _flags_save_string = ndr->flags;
9962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9963                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9964                         ndr->flags = _flags_save_string;
9965                 }
9966                 {
9967                         uint32_t _flags_save_string = ndr->flags;
9968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9970                         ndr->flags = _flags_save_string;
9971                 }
9972                 {
9973                         uint32_t _flags_save_string = ndr->flags;
9974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9976                         ndr->flags = _flags_save_string;
9977                 }
9978                 {
9979                         uint32_t _flags_save_string = ndr->flags;
9980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9982                         ndr->flags = _flags_save_string;
9983                 }
9984         }
9985         if (ndr_flags & NDR_BUFFERS) {
9986                 {
9987                         uint32_t _flags_save_string = ndr->flags;
9988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9989                         if (r->driver_name) {
9990                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9991                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
9999                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10000                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
10008                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10009                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
10017                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10018                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10019                         }
10020                         ndr->flags = _flags_save_string;
10021                 }
10022                 {
10023                         uint32_t _flags_save_string = ndr->flags;
10024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10025                         if (r->config_file) {
10026                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10027                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10028                         }
10029                         ndr->flags = _flags_save_string;
10030                 }
10031         }
10032         return NDR_ERR_SUCCESS;
10033 }
10034
10035 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10036 {
10037         uint32_t _ptr_driver_name;
10038         TALLOC_CTX *_mem_save_driver_name_0;
10039         uint32_t _ptr_architecture;
10040         TALLOC_CTX *_mem_save_architecture_0;
10041         uint32_t _ptr_driver_path;
10042         TALLOC_CTX *_mem_save_driver_path_0;
10043         uint32_t _ptr_data_file;
10044         TALLOC_CTX *_mem_save_data_file_0;
10045         uint32_t _ptr_config_file;
10046         TALLOC_CTX *_mem_save_config_file_0;
10047         if (ndr_flags & NDR_SCALARS) {
10048                 NDR_CHECK(ndr_pull_align(ndr, 4));
10049                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10050                 {
10051                         uint32_t _flags_save_string = ndr->flags;
10052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10053                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10054                         if (_ptr_driver_name) {
10055                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10056                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10057                         } else {
10058                                 r->driver_name = NULL;
10059                         }
10060                         ndr->flags = _flags_save_string;
10061                 }
10062                 {
10063                         uint32_t _flags_save_string = ndr->flags;
10064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10065                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10066                         if (_ptr_architecture) {
10067                                 NDR_PULL_ALLOC(ndr, r->architecture);
10068                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10069                         } else {
10070                                 r->architecture = NULL;
10071                         }
10072                         ndr->flags = _flags_save_string;
10073                 }
10074                 {
10075                         uint32_t _flags_save_string = ndr->flags;
10076                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10077                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10078                         if (_ptr_driver_path) {
10079                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10080                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10081                         } else {
10082                                 r->driver_path = NULL;
10083                         }
10084                         ndr->flags = _flags_save_string;
10085                 }
10086                 {
10087                         uint32_t _flags_save_string = ndr->flags;
10088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10089                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10090                         if (_ptr_data_file) {
10091                                 NDR_PULL_ALLOC(ndr, r->data_file);
10092                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10093                         } else {
10094                                 r->data_file = NULL;
10095                         }
10096                         ndr->flags = _flags_save_string;
10097                 }
10098                 {
10099                         uint32_t _flags_save_string = ndr->flags;
10100                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10101                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10102                         if (_ptr_config_file) {
10103                                 NDR_PULL_ALLOC(ndr, r->config_file);
10104                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10105                         } else {
10106                                 r->config_file = NULL;
10107                         }
10108                         ndr->flags = _flags_save_string;
10109                 }
10110         }
10111         if (ndr_flags & NDR_BUFFERS) {
10112                 {
10113                         uint32_t _flags_save_string = ndr->flags;
10114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10115                         if (r->driver_name) {
10116                                 uint32_t _relative_save_offset;
10117                                 _relative_save_offset = ndr->offset;
10118                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10119                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10120                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10121                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10122                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10123                                 ndr->offset = _relative_save_offset;
10124                         }
10125                         ndr->flags = _flags_save_string;
10126                 }
10127                 {
10128                         uint32_t _flags_save_string = ndr->flags;
10129                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10130                         if (r->architecture) {
10131                                 uint32_t _relative_save_offset;
10132                                 _relative_save_offset = ndr->offset;
10133                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10134                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10135                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10136                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10137                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10138                                 ndr->offset = _relative_save_offset;
10139                         }
10140                         ndr->flags = _flags_save_string;
10141                 }
10142                 {
10143                         uint32_t _flags_save_string = ndr->flags;
10144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10145                         if (r->driver_path) {
10146                                 uint32_t _relative_save_offset;
10147                                 _relative_save_offset = ndr->offset;
10148                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10149                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10150                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10151                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10152                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10153                                 ndr->offset = _relative_save_offset;
10154                         }
10155                         ndr->flags = _flags_save_string;
10156                 }
10157                 {
10158                         uint32_t _flags_save_string = ndr->flags;
10159                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10160                         if (r->data_file) {
10161                                 uint32_t _relative_save_offset;
10162                                 _relative_save_offset = ndr->offset;
10163                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10164                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10165                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10166                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10167                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10168                                 ndr->offset = _relative_save_offset;
10169                         }
10170                         ndr->flags = _flags_save_string;
10171                 }
10172                 {
10173                         uint32_t _flags_save_string = ndr->flags;
10174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10175                         if (r->config_file) {
10176                                 uint32_t _relative_save_offset;
10177                                 _relative_save_offset = ndr->offset;
10178                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10179                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10180                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10181                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10182                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10183                                 ndr->offset = _relative_save_offset;
10184                         }
10185                         ndr->flags = _flags_save_string;
10186                 }
10187         }
10188         return NDR_ERR_SUCCESS;
10189 }
10190
10191 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10192 {
10193         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10194         ndr->depth++;
10195         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10196         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10197         ndr->depth++;
10198         if (r->driver_name) {
10199                 ndr_print_string(ndr, "driver_name", r->driver_name);
10200         }
10201         ndr->depth--;
10202         ndr_print_ptr(ndr, "architecture", r->architecture);
10203         ndr->depth++;
10204         if (r->architecture) {
10205                 ndr_print_string(ndr, "architecture", r->architecture);
10206         }
10207         ndr->depth--;
10208         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10209         ndr->depth++;
10210         if (r->driver_path) {
10211                 ndr_print_string(ndr, "driver_path", r->driver_path);
10212         }
10213         ndr->depth--;
10214         ndr_print_ptr(ndr, "data_file", r->data_file);
10215         ndr->depth++;
10216         if (r->data_file) {
10217                 ndr_print_string(ndr, "data_file", r->data_file);
10218         }
10219         ndr->depth--;
10220         ndr_print_ptr(ndr, "config_file", r->config_file);
10221         ndr->depth++;
10222         if (r->config_file) {
10223                 ndr_print_string(ndr, "config_file", r->config_file);
10224         }
10225         ndr->depth--;
10226         ndr->depth--;
10227 }
10228
10229 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10230 {
10231         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10232 }
10233
10234 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10235 {
10236         if (ndr_flags & NDR_SCALARS) {
10237                 NDR_CHECK(ndr_push_align(ndr, 4));
10238                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10239                 {
10240                         uint32_t _flags_save_string = ndr->flags;
10241                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10242                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10243                         ndr->flags = _flags_save_string;
10244                 }
10245                 {
10246                         uint32_t _flags_save_string = ndr->flags;
10247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10248                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10249                         ndr->flags = _flags_save_string;
10250                 }
10251                 {
10252                         uint32_t _flags_save_string = ndr->flags;
10253                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10254                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10255                         ndr->flags = _flags_save_string;
10256                 }
10257                 {
10258                         uint32_t _flags_save_string = ndr->flags;
10259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10260                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10261                         ndr->flags = _flags_save_string;
10262                 }
10263                 {
10264                         uint32_t _flags_save_string = ndr->flags;
10265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10266                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10267                         ndr->flags = _flags_save_string;
10268                 }
10269                 {
10270                         uint32_t _flags_save_string = ndr->flags;
10271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10272                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10273                         ndr->flags = _flags_save_string;
10274                 }
10275                 {
10276                         uint32_t _flags_save_string_array = ndr->flags;
10277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10278                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10279                         ndr->flags = _flags_save_string_array;
10280                 }
10281                 {
10282                         uint32_t _flags_save_string = ndr->flags;
10283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10284                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10285                         ndr->flags = _flags_save_string;
10286                 }
10287                 {
10288                         uint32_t _flags_save_string = ndr->flags;
10289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10290                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10291                         ndr->flags = _flags_save_string;
10292                 }
10293         }
10294         if (ndr_flags & NDR_BUFFERS) {
10295                 {
10296                         uint32_t _flags_save_string = ndr->flags;
10297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10298                         if (r->driver_name) {
10299                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10300                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
10308                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10309                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
10317                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10318                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
10326                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10327                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_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->config_file) {
10335                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10336                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10337                         }
10338                         ndr->flags = _flags_save_string;
10339                 }
10340                 {
10341                         uint32_t _flags_save_string = ndr->flags;
10342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10343                         if (r->help_file) {
10344                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10345                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10346                         }
10347                         ndr->flags = _flags_save_string;
10348                 }
10349                 {
10350                         uint32_t _flags_save_string_array = ndr->flags;
10351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10352                         if (r->dependent_files) {
10353                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10354                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10355                         }
10356                         ndr->flags = _flags_save_string_array;
10357                 }
10358                 {
10359                         uint32_t _flags_save_string = ndr->flags;
10360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10361                         if (r->monitor_name) {
10362                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10363                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10364                         }
10365                         ndr->flags = _flags_save_string;
10366                 }
10367                 {
10368                         uint32_t _flags_save_string = ndr->flags;
10369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10370                         if (r->default_datatype) {
10371                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10372                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10373                         }
10374                         ndr->flags = _flags_save_string;
10375                 }
10376         }
10377         return NDR_ERR_SUCCESS;
10378 }
10379
10380 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10381 {
10382         uint32_t _ptr_driver_name;
10383         TALLOC_CTX *_mem_save_driver_name_0;
10384         uint32_t _ptr_architecture;
10385         TALLOC_CTX *_mem_save_architecture_0;
10386         uint32_t _ptr_driver_path;
10387         TALLOC_CTX *_mem_save_driver_path_0;
10388         uint32_t _ptr_data_file;
10389         TALLOC_CTX *_mem_save_data_file_0;
10390         uint32_t _ptr_config_file;
10391         TALLOC_CTX *_mem_save_config_file_0;
10392         uint32_t _ptr_help_file;
10393         TALLOC_CTX *_mem_save_help_file_0;
10394         uint32_t _ptr_dependent_files;
10395         TALLOC_CTX *_mem_save_dependent_files_0;
10396         uint32_t _ptr_monitor_name;
10397         TALLOC_CTX *_mem_save_monitor_name_0;
10398         uint32_t _ptr_default_datatype;
10399         TALLOC_CTX *_mem_save_default_datatype_0;
10400         if (ndr_flags & NDR_SCALARS) {
10401                 NDR_CHECK(ndr_pull_align(ndr, 4));
10402                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10403                 {
10404                         uint32_t _flags_save_string = ndr->flags;
10405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10406                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10407                         if (_ptr_driver_name) {
10408                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10409                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10410                         } else {
10411                                 r->driver_name = NULL;
10412                         }
10413                         ndr->flags = _flags_save_string;
10414                 }
10415                 {
10416                         uint32_t _flags_save_string = ndr->flags;
10417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10418                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10419                         if (_ptr_architecture) {
10420                                 NDR_PULL_ALLOC(ndr, r->architecture);
10421                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10422                         } else {
10423                                 r->architecture = NULL;
10424                         }
10425                         ndr->flags = _flags_save_string;
10426                 }
10427                 {
10428                         uint32_t _flags_save_string = ndr->flags;
10429                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10430                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10431                         if (_ptr_driver_path) {
10432                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10433                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10434                         } else {
10435                                 r->driver_path = NULL;
10436                         }
10437                         ndr->flags = _flags_save_string;
10438                 }
10439                 {
10440                         uint32_t _flags_save_string = ndr->flags;
10441                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10442                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10443                         if (_ptr_data_file) {
10444                                 NDR_PULL_ALLOC(ndr, r->data_file);
10445                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10446                         } else {
10447                                 r->data_file = NULL;
10448                         }
10449                         ndr->flags = _flags_save_string;
10450                 }
10451                 {
10452                         uint32_t _flags_save_string = ndr->flags;
10453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10454                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10455                         if (_ptr_config_file) {
10456                                 NDR_PULL_ALLOC(ndr, r->config_file);
10457                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10458                         } else {
10459                                 r->config_file = NULL;
10460                         }
10461                         ndr->flags = _flags_save_string;
10462                 }
10463                 {
10464                         uint32_t _flags_save_string = ndr->flags;
10465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10466                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10467                         if (_ptr_help_file) {
10468                                 NDR_PULL_ALLOC(ndr, r->help_file);
10469                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10470                         } else {
10471                                 r->help_file = NULL;
10472                         }
10473                         ndr->flags = _flags_save_string;
10474                 }
10475                 {
10476                         uint32_t _flags_save_string_array = ndr->flags;
10477                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10478                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10479                         if (_ptr_dependent_files) {
10480                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10481                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10482                         } else {
10483                                 r->dependent_files = NULL;
10484                         }
10485                         ndr->flags = _flags_save_string_array;
10486                 }
10487                 {
10488                         uint32_t _flags_save_string = ndr->flags;
10489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10490                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10491                         if (_ptr_monitor_name) {
10492                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10493                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10494                         } else {
10495                                 r->monitor_name = NULL;
10496                         }
10497                         ndr->flags = _flags_save_string;
10498                 }
10499                 {
10500                         uint32_t _flags_save_string = ndr->flags;
10501                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10502                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10503                         if (_ptr_default_datatype) {
10504                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10505                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10506                         } else {
10507                                 r->default_datatype = NULL;
10508                         }
10509                         ndr->flags = _flags_save_string;
10510                 }
10511         }
10512         if (ndr_flags & NDR_BUFFERS) {
10513                 {
10514                         uint32_t _flags_save_string = ndr->flags;
10515                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10516                         if (r->driver_name) {
10517                                 uint32_t _relative_save_offset;
10518                                 _relative_save_offset = ndr->offset;
10519                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10520                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10521                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10522                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10523                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10524                                 ndr->offset = _relative_save_offset;
10525                         }
10526                         ndr->flags = _flags_save_string;
10527                 }
10528                 {
10529                         uint32_t _flags_save_string = ndr->flags;
10530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10531                         if (r->architecture) {
10532                                 uint32_t _relative_save_offset;
10533                                 _relative_save_offset = ndr->offset;
10534                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10535                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10536                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10537                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10538                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10539                                 ndr->offset = _relative_save_offset;
10540                         }
10541                         ndr->flags = _flags_save_string;
10542                 }
10543                 {
10544                         uint32_t _flags_save_string = ndr->flags;
10545                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10546                         if (r->driver_path) {
10547                                 uint32_t _relative_save_offset;
10548                                 _relative_save_offset = ndr->offset;
10549                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10550                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10551                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10552                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10553                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10554                                 ndr->offset = _relative_save_offset;
10555                         }
10556                         ndr->flags = _flags_save_string;
10557                 }
10558                 {
10559                         uint32_t _flags_save_string = ndr->flags;
10560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10561                         if (r->data_file) {
10562                                 uint32_t _relative_save_offset;
10563                                 _relative_save_offset = ndr->offset;
10564                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10565                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10566                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10567                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10568                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10569                                 ndr->offset = _relative_save_offset;
10570                         }
10571                         ndr->flags = _flags_save_string;
10572                 }
10573                 {
10574                         uint32_t _flags_save_string = ndr->flags;
10575                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10576                         if (r->config_file) {
10577                                 uint32_t _relative_save_offset;
10578                                 _relative_save_offset = ndr->offset;
10579                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10580                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10581                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10582                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10583                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10584                                 ndr->offset = _relative_save_offset;
10585                         }
10586                         ndr->flags = _flags_save_string;
10587                 }
10588                 {
10589                         uint32_t _flags_save_string = ndr->flags;
10590                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10591                         if (r->help_file) {
10592                                 uint32_t _relative_save_offset;
10593                                 _relative_save_offset = ndr->offset;
10594                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10595                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10596                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10597                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10598                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10599                                 ndr->offset = _relative_save_offset;
10600                         }
10601                         ndr->flags = _flags_save_string;
10602                 }
10603                 {
10604                         uint32_t _flags_save_string_array = ndr->flags;
10605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10606                         if (r->dependent_files) {
10607                                 uint32_t _relative_save_offset;
10608                                 _relative_save_offset = ndr->offset;
10609                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10610                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10611                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10612                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10613                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10614                                 ndr->offset = _relative_save_offset;
10615                         }
10616                         ndr->flags = _flags_save_string_array;
10617                 }
10618                 {
10619                         uint32_t _flags_save_string = ndr->flags;
10620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10621                         if (r->monitor_name) {
10622                                 uint32_t _relative_save_offset;
10623                                 _relative_save_offset = ndr->offset;
10624                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10625                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10626                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10627                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10628                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10629                                 ndr->offset = _relative_save_offset;
10630                         }
10631                         ndr->flags = _flags_save_string;
10632                 }
10633                 {
10634                         uint32_t _flags_save_string = ndr->flags;
10635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10636                         if (r->default_datatype) {
10637                                 uint32_t _relative_save_offset;
10638                                 _relative_save_offset = ndr->offset;
10639                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10640                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10641                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10642                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10643                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10644                                 ndr->offset = _relative_save_offset;
10645                         }
10646                         ndr->flags = _flags_save_string;
10647                 }
10648         }
10649         return NDR_ERR_SUCCESS;
10650 }
10651
10652 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10653 {
10654         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10655         ndr->depth++;
10656         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10657         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10658         ndr->depth++;
10659         if (r->driver_name) {
10660                 ndr_print_string(ndr, "driver_name", r->driver_name);
10661         }
10662         ndr->depth--;
10663         ndr_print_ptr(ndr, "architecture", r->architecture);
10664         ndr->depth++;
10665         if (r->architecture) {
10666                 ndr_print_string(ndr, "architecture", r->architecture);
10667         }
10668         ndr->depth--;
10669         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10670         ndr->depth++;
10671         if (r->driver_path) {
10672                 ndr_print_string(ndr, "driver_path", r->driver_path);
10673         }
10674         ndr->depth--;
10675         ndr_print_ptr(ndr, "data_file", r->data_file);
10676         ndr->depth++;
10677         if (r->data_file) {
10678                 ndr_print_string(ndr, "data_file", r->data_file);
10679         }
10680         ndr->depth--;
10681         ndr_print_ptr(ndr, "config_file", r->config_file);
10682         ndr->depth++;
10683         if (r->config_file) {
10684                 ndr_print_string(ndr, "config_file", r->config_file);
10685         }
10686         ndr->depth--;
10687         ndr_print_ptr(ndr, "help_file", r->help_file);
10688         ndr->depth++;
10689         if (r->help_file) {
10690                 ndr_print_string(ndr, "help_file", r->help_file);
10691         }
10692         ndr->depth--;
10693         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10694         ndr->depth++;
10695         if (r->dependent_files) {
10696                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10697         }
10698         ndr->depth--;
10699         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10700         ndr->depth++;
10701         if (r->monitor_name) {
10702                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10703         }
10704         ndr->depth--;
10705         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10706         ndr->depth++;
10707         if (r->default_datatype) {
10708                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10709         }
10710         ndr->depth--;
10711         ndr->depth--;
10712 }
10713
10714 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10715 {
10716         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10717 }
10718
10719 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10720 {
10721         if (ndr_flags & NDR_SCALARS) {
10722                 NDR_CHECK(ndr_push_align(ndr, 4));
10723                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10724                 {
10725                         uint32_t _flags_save_string = ndr->flags;
10726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10727                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10728                         ndr->flags = _flags_save_string;
10729                 }
10730                 {
10731                         uint32_t _flags_save_string = ndr->flags;
10732                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10733                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10734                         ndr->flags = _flags_save_string;
10735                 }
10736                 {
10737                         uint32_t _flags_save_string = ndr->flags;
10738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10739                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10740                         ndr->flags = _flags_save_string;
10741                 }
10742                 {
10743                         uint32_t _flags_save_string = ndr->flags;
10744                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10745                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10746                         ndr->flags = _flags_save_string;
10747                 }
10748                 {
10749                         uint32_t _flags_save_string = ndr->flags;
10750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10751                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10752                         ndr->flags = _flags_save_string;
10753                 }
10754                 {
10755                         uint32_t _flags_save_string = ndr->flags;
10756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10757                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10758                         ndr->flags = _flags_save_string;
10759                 }
10760                 {
10761                         uint32_t _flags_save_string_array = ndr->flags;
10762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10763                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10764                         ndr->flags = _flags_save_string_array;
10765                 }
10766                 {
10767                         uint32_t _flags_save_string = ndr->flags;
10768                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10769                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10770                         ndr->flags = _flags_save_string;
10771                 }
10772                 {
10773                         uint32_t _flags_save_string = ndr->flags;
10774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10775                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10776                         ndr->flags = _flags_save_string;
10777                 }
10778                 {
10779                         uint32_t _flags_save_string_array = ndr->flags;
10780                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10781                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10782                         ndr->flags = _flags_save_string_array;
10783                 }
10784         }
10785         if (ndr_flags & NDR_BUFFERS) {
10786                 {
10787                         uint32_t _flags_save_string = ndr->flags;
10788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10789                         if (r->driver_name) {
10790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
10799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
10808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
10817                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10818                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_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->config_file) {
10826                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10827                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10828                         }
10829                         ndr->flags = _flags_save_string;
10830                 }
10831                 {
10832                         uint32_t _flags_save_string = ndr->flags;
10833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10834                         if (r->help_file) {
10835                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10836                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10837                         }
10838                         ndr->flags = _flags_save_string;
10839                 }
10840                 {
10841                         uint32_t _flags_save_string_array = ndr->flags;
10842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10843                         if (r->dependent_files) {
10844                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10845                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10846                         }
10847                         ndr->flags = _flags_save_string_array;
10848                 }
10849                 {
10850                         uint32_t _flags_save_string = ndr->flags;
10851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10852                         if (r->monitor_name) {
10853                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10854                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10855                         }
10856                         ndr->flags = _flags_save_string;
10857                 }
10858                 {
10859                         uint32_t _flags_save_string = ndr->flags;
10860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10861                         if (r->default_datatype) {
10862                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10863                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10864                         }
10865                         ndr->flags = _flags_save_string;
10866                 }
10867                 {
10868                         uint32_t _flags_save_string_array = ndr->flags;
10869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10870                         if (r->previous_names) {
10871                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10872                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10873                         }
10874                         ndr->flags = _flags_save_string_array;
10875                 }
10876         }
10877         return NDR_ERR_SUCCESS;
10878 }
10879
10880 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10881 {
10882         uint32_t _ptr_driver_name;
10883         TALLOC_CTX *_mem_save_driver_name_0;
10884         uint32_t _ptr_architecture;
10885         TALLOC_CTX *_mem_save_architecture_0;
10886         uint32_t _ptr_driver_path;
10887         TALLOC_CTX *_mem_save_driver_path_0;
10888         uint32_t _ptr_data_file;
10889         TALLOC_CTX *_mem_save_data_file_0;
10890         uint32_t _ptr_config_file;
10891         TALLOC_CTX *_mem_save_config_file_0;
10892         uint32_t _ptr_help_file;
10893         TALLOC_CTX *_mem_save_help_file_0;
10894         uint32_t _ptr_dependent_files;
10895         TALLOC_CTX *_mem_save_dependent_files_0;
10896         uint32_t _ptr_monitor_name;
10897         TALLOC_CTX *_mem_save_monitor_name_0;
10898         uint32_t _ptr_default_datatype;
10899         TALLOC_CTX *_mem_save_default_datatype_0;
10900         uint32_t _ptr_previous_names;
10901         TALLOC_CTX *_mem_save_previous_names_0;
10902         if (ndr_flags & NDR_SCALARS) {
10903                 NDR_CHECK(ndr_pull_align(ndr, 4));
10904                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10905                 {
10906                         uint32_t _flags_save_string = ndr->flags;
10907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10908                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10909                         if (_ptr_driver_name) {
10910                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10911                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10912                         } else {
10913                                 r->driver_name = NULL;
10914                         }
10915                         ndr->flags = _flags_save_string;
10916                 }
10917                 {
10918                         uint32_t _flags_save_string = ndr->flags;
10919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10920                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10921                         if (_ptr_architecture) {
10922                                 NDR_PULL_ALLOC(ndr, r->architecture);
10923                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10924                         } else {
10925                                 r->architecture = NULL;
10926                         }
10927                         ndr->flags = _flags_save_string;
10928                 }
10929                 {
10930                         uint32_t _flags_save_string = ndr->flags;
10931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10932                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10933                         if (_ptr_driver_path) {
10934                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10935                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10936                         } else {
10937                                 r->driver_path = NULL;
10938                         }
10939                         ndr->flags = _flags_save_string;
10940                 }
10941                 {
10942                         uint32_t _flags_save_string = ndr->flags;
10943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10944                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10945                         if (_ptr_data_file) {
10946                                 NDR_PULL_ALLOC(ndr, r->data_file);
10947                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10948                         } else {
10949                                 r->data_file = NULL;
10950                         }
10951                         ndr->flags = _flags_save_string;
10952                 }
10953                 {
10954                         uint32_t _flags_save_string = ndr->flags;
10955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10956                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10957                         if (_ptr_config_file) {
10958                                 NDR_PULL_ALLOC(ndr, r->config_file);
10959                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10960                         } else {
10961                                 r->config_file = NULL;
10962                         }
10963                         ndr->flags = _flags_save_string;
10964                 }
10965                 {
10966                         uint32_t _flags_save_string = ndr->flags;
10967                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10968                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10969                         if (_ptr_help_file) {
10970                                 NDR_PULL_ALLOC(ndr, r->help_file);
10971                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10972                         } else {
10973                                 r->help_file = NULL;
10974                         }
10975                         ndr->flags = _flags_save_string;
10976                 }
10977                 {
10978                         uint32_t _flags_save_string_array = ndr->flags;
10979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10980                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10981                         if (_ptr_dependent_files) {
10982                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10983                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10984                         } else {
10985                                 r->dependent_files = NULL;
10986                         }
10987                         ndr->flags = _flags_save_string_array;
10988                 }
10989                 {
10990                         uint32_t _flags_save_string = ndr->flags;
10991                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10992                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10993                         if (_ptr_monitor_name) {
10994                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10995                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10996                         } else {
10997                                 r->monitor_name = NULL;
10998                         }
10999                         ndr->flags = _flags_save_string;
11000                 }
11001                 {
11002                         uint32_t _flags_save_string = ndr->flags;
11003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11004                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11005                         if (_ptr_default_datatype) {
11006                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11007                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11008                         } else {
11009                                 r->default_datatype = NULL;
11010                         }
11011                         ndr->flags = _flags_save_string;
11012                 }
11013                 {
11014                         uint32_t _flags_save_string_array = ndr->flags;
11015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11016                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11017                         if (_ptr_previous_names) {
11018                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11019                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11020                         } else {
11021                                 r->previous_names = NULL;
11022                         }
11023                         ndr->flags = _flags_save_string_array;
11024                 }
11025         }
11026         if (ndr_flags & NDR_BUFFERS) {
11027                 {
11028                         uint32_t _flags_save_string = ndr->flags;
11029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11030                         if (r->driver_name) {
11031                                 uint32_t _relative_save_offset;
11032                                 _relative_save_offset = ndr->offset;
11033                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11034                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11035                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11036                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11037                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11038                                 ndr->offset = _relative_save_offset;
11039                         }
11040                         ndr->flags = _flags_save_string;
11041                 }
11042                 {
11043                         uint32_t _flags_save_string = ndr->flags;
11044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11045                         if (r->architecture) {
11046                                 uint32_t _relative_save_offset;
11047                                 _relative_save_offset = ndr->offset;
11048                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11049                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11050                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11051                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11052                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11053                                 ndr->offset = _relative_save_offset;
11054                         }
11055                         ndr->flags = _flags_save_string;
11056                 }
11057                 {
11058                         uint32_t _flags_save_string = ndr->flags;
11059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11060                         if (r->driver_path) {
11061                                 uint32_t _relative_save_offset;
11062                                 _relative_save_offset = ndr->offset;
11063                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11064                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11065                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11066                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11067                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11068                                 ndr->offset = _relative_save_offset;
11069                         }
11070                         ndr->flags = _flags_save_string;
11071                 }
11072                 {
11073                         uint32_t _flags_save_string = ndr->flags;
11074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11075                         if (r->data_file) {
11076                                 uint32_t _relative_save_offset;
11077                                 _relative_save_offset = ndr->offset;
11078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11079                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11080                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11083                                 ndr->offset = _relative_save_offset;
11084                         }
11085                         ndr->flags = _flags_save_string;
11086                 }
11087                 {
11088                         uint32_t _flags_save_string = ndr->flags;
11089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11090                         if (r->config_file) {
11091                                 uint32_t _relative_save_offset;
11092                                 _relative_save_offset = ndr->offset;
11093                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11094                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11095                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11096                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11097                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11098                                 ndr->offset = _relative_save_offset;
11099                         }
11100                         ndr->flags = _flags_save_string;
11101                 }
11102                 {
11103                         uint32_t _flags_save_string = ndr->flags;
11104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11105                         if (r->help_file) {
11106                                 uint32_t _relative_save_offset;
11107                                 _relative_save_offset = ndr->offset;
11108                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11109                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11110                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11111                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11112                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11113                                 ndr->offset = _relative_save_offset;
11114                         }
11115                         ndr->flags = _flags_save_string;
11116                 }
11117                 {
11118                         uint32_t _flags_save_string_array = ndr->flags;
11119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11120                         if (r->dependent_files) {
11121                                 uint32_t _relative_save_offset;
11122                                 _relative_save_offset = ndr->offset;
11123                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11124                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11125                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11126                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11127                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11128                                 ndr->offset = _relative_save_offset;
11129                         }
11130                         ndr->flags = _flags_save_string_array;
11131                 }
11132                 {
11133                         uint32_t _flags_save_string = ndr->flags;
11134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11135                         if (r->monitor_name) {
11136                                 uint32_t _relative_save_offset;
11137                                 _relative_save_offset = ndr->offset;
11138                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11139                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11140                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11141                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11142                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11143                                 ndr->offset = _relative_save_offset;
11144                         }
11145                         ndr->flags = _flags_save_string;
11146                 }
11147                 {
11148                         uint32_t _flags_save_string = ndr->flags;
11149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11150                         if (r->default_datatype) {
11151                                 uint32_t _relative_save_offset;
11152                                 _relative_save_offset = ndr->offset;
11153                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11154                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11155                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11156                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11157                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11158                                 ndr->offset = _relative_save_offset;
11159                         }
11160                         ndr->flags = _flags_save_string;
11161                 }
11162                 {
11163                         uint32_t _flags_save_string_array = ndr->flags;
11164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11165                         if (r->previous_names) {
11166                                 uint32_t _relative_save_offset;
11167                                 _relative_save_offset = ndr->offset;
11168                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11169                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11170                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11171                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11172                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11173                                 ndr->offset = _relative_save_offset;
11174                         }
11175                         ndr->flags = _flags_save_string_array;
11176                 }
11177         }
11178         return NDR_ERR_SUCCESS;
11179 }
11180
11181 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11182 {
11183         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11184         ndr->depth++;
11185         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11186         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11187         ndr->depth++;
11188         if (r->driver_name) {
11189                 ndr_print_string(ndr, "driver_name", r->driver_name);
11190         }
11191         ndr->depth--;
11192         ndr_print_ptr(ndr, "architecture", r->architecture);
11193         ndr->depth++;
11194         if (r->architecture) {
11195                 ndr_print_string(ndr, "architecture", r->architecture);
11196         }
11197         ndr->depth--;
11198         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11199         ndr->depth++;
11200         if (r->driver_path) {
11201                 ndr_print_string(ndr, "driver_path", r->driver_path);
11202         }
11203         ndr->depth--;
11204         ndr_print_ptr(ndr, "data_file", r->data_file);
11205         ndr->depth++;
11206         if (r->data_file) {
11207                 ndr_print_string(ndr, "data_file", r->data_file);
11208         }
11209         ndr->depth--;
11210         ndr_print_ptr(ndr, "config_file", r->config_file);
11211         ndr->depth++;
11212         if (r->config_file) {
11213                 ndr_print_string(ndr, "config_file", r->config_file);
11214         }
11215         ndr->depth--;
11216         ndr_print_ptr(ndr, "help_file", r->help_file);
11217         ndr->depth++;
11218         if (r->help_file) {
11219                 ndr_print_string(ndr, "help_file", r->help_file);
11220         }
11221         ndr->depth--;
11222         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11223         ndr->depth++;
11224         if (r->dependent_files) {
11225                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11226         }
11227         ndr->depth--;
11228         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11229         ndr->depth++;
11230         if (r->monitor_name) {
11231                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11232         }
11233         ndr->depth--;
11234         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11235         ndr->depth++;
11236         if (r->default_datatype) {
11237                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11238         }
11239         ndr->depth--;
11240         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11241         ndr->depth++;
11242         if (r->previous_names) {
11243                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11244         }
11245         ndr->depth--;
11246         ndr->depth--;
11247 }
11248
11249 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11250 {
11251         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11252 }
11253
11254 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11255 {
11256         if (ndr_flags & NDR_SCALARS) {
11257                 NDR_CHECK(ndr_push_align(ndr, 4));
11258                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11259                 {
11260                         uint32_t _flags_save_string = ndr->flags;
11261                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11262                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11263                         ndr->flags = _flags_save_string;
11264                 }
11265                 {
11266                         uint32_t _flags_save_string = ndr->flags;
11267                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11268                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11269                         ndr->flags = _flags_save_string;
11270                 }
11271                 {
11272                         uint32_t _flags_save_string = ndr->flags;
11273                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11274                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11275                         ndr->flags = _flags_save_string;
11276                 }
11277                 {
11278                         uint32_t _flags_save_string = ndr->flags;
11279                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11280                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11281                         ndr->flags = _flags_save_string;
11282                 }
11283                 {
11284                         uint32_t _flags_save_string = ndr->flags;
11285                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11286                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11287                         ndr->flags = _flags_save_string;
11288                 }
11289                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
11290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11292         }
11293         if (ndr_flags & NDR_BUFFERS) {
11294                 {
11295                         uint32_t _flags_save_string = ndr->flags;
11296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11297                         if (r->driver_name) {
11298                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11299                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
11307                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11308                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
11316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
11325                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11326                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11327                         }
11328                         ndr->flags = _flags_save_string;
11329                 }
11330                 {
11331                         uint32_t _flags_save_string = ndr->flags;
11332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11333                         if (r->config_file) {
11334                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11335                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11336                         }
11337                         ndr->flags = _flags_save_string;
11338                 }
11339         }
11340         return NDR_ERR_SUCCESS;
11341 }
11342
11343 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11344 {
11345         uint32_t _ptr_driver_name;
11346         TALLOC_CTX *_mem_save_driver_name_0;
11347         uint32_t _ptr_architecture;
11348         TALLOC_CTX *_mem_save_architecture_0;
11349         uint32_t _ptr_driver_path;
11350         TALLOC_CTX *_mem_save_driver_path_0;
11351         uint32_t _ptr_data_file;
11352         TALLOC_CTX *_mem_save_data_file_0;
11353         uint32_t _ptr_config_file;
11354         TALLOC_CTX *_mem_save_config_file_0;
11355         if (ndr_flags & NDR_SCALARS) {
11356                 NDR_CHECK(ndr_pull_align(ndr, 4));
11357                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11358                 {
11359                         uint32_t _flags_save_string = ndr->flags;
11360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11361                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11362                         if (_ptr_driver_name) {
11363                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11364                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11365                         } else {
11366                                 r->driver_name = NULL;
11367                         }
11368                         ndr->flags = _flags_save_string;
11369                 }
11370                 {
11371                         uint32_t _flags_save_string = ndr->flags;
11372                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11373                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11374                         if (_ptr_architecture) {
11375                                 NDR_PULL_ALLOC(ndr, r->architecture);
11376                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11377                         } else {
11378                                 r->architecture = NULL;
11379                         }
11380                         ndr->flags = _flags_save_string;
11381                 }
11382                 {
11383                         uint32_t _flags_save_string = ndr->flags;
11384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11386                         if (_ptr_driver_path) {
11387                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11389                         } else {
11390                                 r->driver_path = NULL;
11391                         }
11392                         ndr->flags = _flags_save_string;
11393                 }
11394                 {
11395                         uint32_t _flags_save_string = ndr->flags;
11396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11398                         if (_ptr_data_file) {
11399                                 NDR_PULL_ALLOC(ndr, r->data_file);
11400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11401                         } else {
11402                                 r->data_file = NULL;
11403                         }
11404                         ndr->flags = _flags_save_string;
11405                 }
11406                 {
11407                         uint32_t _flags_save_string = ndr->flags;
11408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11409                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11410                         if (_ptr_config_file) {
11411                                 NDR_PULL_ALLOC(ndr, r->config_file);
11412                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11413                         } else {
11414                                 r->config_file = NULL;
11415                         }
11416                         ndr->flags = _flags_save_string;
11417                 }
11418                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
11419                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11421         }
11422         if (ndr_flags & NDR_BUFFERS) {
11423                 {
11424                         uint32_t _flags_save_string = ndr->flags;
11425                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11426                         if (r->driver_name) {
11427                                 uint32_t _relative_save_offset;
11428                                 _relative_save_offset = ndr->offset;
11429                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11430                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11431                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11432                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11433                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11434                                 ndr->offset = _relative_save_offset;
11435                         }
11436                         ndr->flags = _flags_save_string;
11437                 }
11438                 {
11439                         uint32_t _flags_save_string = ndr->flags;
11440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11441                         if (r->architecture) {
11442                                 uint32_t _relative_save_offset;
11443                                 _relative_save_offset = ndr->offset;
11444                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11445                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11446                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11447                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11448                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11449                                 ndr->offset = _relative_save_offset;
11450                         }
11451                         ndr->flags = _flags_save_string;
11452                 }
11453                 {
11454                         uint32_t _flags_save_string = ndr->flags;
11455                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11456                         if (r->driver_path) {
11457                                 uint32_t _relative_save_offset;
11458                                 _relative_save_offset = ndr->offset;
11459                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11460                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11461                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11462                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11463                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11464                                 ndr->offset = _relative_save_offset;
11465                         }
11466                         ndr->flags = _flags_save_string;
11467                 }
11468                 {
11469                         uint32_t _flags_save_string = ndr->flags;
11470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11471                         if (r->data_file) {
11472                                 uint32_t _relative_save_offset;
11473                                 _relative_save_offset = ndr->offset;
11474                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11475                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11476                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11477                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11478                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11479                                 ndr->offset = _relative_save_offset;
11480                         }
11481                         ndr->flags = _flags_save_string;
11482                 }
11483                 {
11484                         uint32_t _flags_save_string = ndr->flags;
11485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11486                         if (r->config_file) {
11487                                 uint32_t _relative_save_offset;
11488                                 _relative_save_offset = ndr->offset;
11489                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11490                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11491                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11492                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11493                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11494                                 ndr->offset = _relative_save_offset;
11495                         }
11496                         ndr->flags = _flags_save_string;
11497                 }
11498         }
11499         return NDR_ERR_SUCCESS;
11500 }
11501
11502 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11503 {
11504         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11505         ndr->depth++;
11506         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11507         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11508         ndr->depth++;
11509         if (r->driver_name) {
11510                 ndr_print_string(ndr, "driver_name", r->driver_name);
11511         }
11512         ndr->depth--;
11513         ndr_print_ptr(ndr, "architecture", r->architecture);
11514         ndr->depth++;
11515         if (r->architecture) {
11516                 ndr_print_string(ndr, "architecture", r->architecture);
11517         }
11518         ndr->depth--;
11519         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11520         ndr->depth++;
11521         if (r->driver_path) {
11522                 ndr_print_string(ndr, "driver_path", r->driver_path);
11523         }
11524         ndr->depth--;
11525         ndr_print_ptr(ndr, "data_file", r->data_file);
11526         ndr->depth++;
11527         if (r->data_file) {
11528                 ndr_print_string(ndr, "data_file", r->data_file);
11529         }
11530         ndr->depth--;
11531         ndr_print_ptr(ndr, "config_file", r->config_file);
11532         ndr->depth++;
11533         if (r->config_file) {
11534                 ndr_print_string(ndr, "config_file", r->config_file);
11535         }
11536         ndr->depth--;
11537         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
11538         ndr_print_uint32(ndr, "config_version", r->config_version);
11539         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11540         ndr->depth--;
11541 }
11542
11543 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11544 {
11545         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11546 }
11547
11548 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11549 {
11550         if (ndr_flags & NDR_SCALARS) {
11551                 NDR_CHECK(ndr_push_align(ndr, 8));
11552                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11553                 {
11554                         uint32_t _flags_save_string = ndr->flags;
11555                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11556                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11557                         ndr->flags = _flags_save_string;
11558                 }
11559                 {
11560                         uint32_t _flags_save_string = ndr->flags;
11561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11562                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11563                         ndr->flags = _flags_save_string;
11564                 }
11565                 {
11566                         uint32_t _flags_save_string = ndr->flags;
11567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11568                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11569                         ndr->flags = _flags_save_string;
11570                 }
11571                 {
11572                         uint32_t _flags_save_string = ndr->flags;
11573                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11574                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11575                         ndr->flags = _flags_save_string;
11576                 }
11577                 {
11578                         uint32_t _flags_save_string = ndr->flags;
11579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11580                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11581                         ndr->flags = _flags_save_string;
11582                 }
11583                 {
11584                         uint32_t _flags_save_string = ndr->flags;
11585                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11586                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11587                         ndr->flags = _flags_save_string;
11588                 }
11589                 {
11590                         uint32_t _flags_save_string_array = ndr->flags;
11591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11592                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11593                         ndr->flags = _flags_save_string_array;
11594                 }
11595                 {
11596                         uint32_t _flags_save_string = ndr->flags;
11597                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11598                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11599                         ndr->flags = _flags_save_string;
11600                 }
11601                 {
11602                         uint32_t _flags_save_string = ndr->flags;
11603                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11604                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11605                         ndr->flags = _flags_save_string;
11606                 }
11607                 {
11608                         uint32_t _flags_save_string_array = ndr->flags;
11609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11610                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11611                         ndr->flags = _flags_save_string_array;
11612                 }
11613                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11614                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11615                 {
11616                         uint32_t _flags_save_string = ndr->flags;
11617                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11618                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11619                         ndr->flags = _flags_save_string;
11620                 }
11621                 {
11622                         uint32_t _flags_save_string = ndr->flags;
11623                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11624                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11625                         ndr->flags = _flags_save_string;
11626                 }
11627                 {
11628                         uint32_t _flags_save_string = ndr->flags;
11629                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11630                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11631                         ndr->flags = _flags_save_string;
11632                 }
11633                 {
11634                         uint32_t _flags_save_string = ndr->flags;
11635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11636                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11637                         ndr->flags = _flags_save_string;
11638                 }
11639         }
11640         if (ndr_flags & NDR_BUFFERS) {
11641                 {
11642                         uint32_t _flags_save_string = ndr->flags;
11643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11644                         if (r->driver_name) {
11645                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
11654                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11655                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
11663                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
11672                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11673                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_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->config_file) {
11681                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11682                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11683                         }
11684                         ndr->flags = _flags_save_string;
11685                 }
11686                 {
11687                         uint32_t _flags_save_string = ndr->flags;
11688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11689                         if (r->help_file) {
11690                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11691                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11692                         }
11693                         ndr->flags = _flags_save_string;
11694                 }
11695                 {
11696                         uint32_t _flags_save_string_array = ndr->flags;
11697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11698                         if (r->dependent_files) {
11699                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11700                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11701                         }
11702                         ndr->flags = _flags_save_string_array;
11703                 }
11704                 {
11705                         uint32_t _flags_save_string = ndr->flags;
11706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11707                         if (r->monitor_name) {
11708                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11710                         }
11711                         ndr->flags = _flags_save_string;
11712                 }
11713                 {
11714                         uint32_t _flags_save_string = ndr->flags;
11715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11716                         if (r->default_datatype) {
11717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11718                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11719                         }
11720                         ndr->flags = _flags_save_string;
11721                 }
11722                 {
11723                         uint32_t _flags_save_string_array = ndr->flags;
11724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11725                         if (r->previous_names) {
11726                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11727                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11728                         }
11729                         ndr->flags = _flags_save_string_array;
11730                 }
11731                 {
11732                         uint32_t _flags_save_string = ndr->flags;
11733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11734                         if (r->manufacturer_name) {
11735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11736                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
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->manufacturer_url) {
11744                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11745                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
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->hardware_id) {
11753                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11754                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11755                         }
11756                         ndr->flags = _flags_save_string;
11757                 }
11758                 {
11759                         uint32_t _flags_save_string = ndr->flags;
11760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11761                         if (r->provider) {
11762                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11763                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11764                         }
11765                         ndr->flags = _flags_save_string;
11766                 }
11767         }
11768         return NDR_ERR_SUCCESS;
11769 }
11770
11771 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11772 {
11773         uint32_t _ptr_driver_name;
11774         TALLOC_CTX *_mem_save_driver_name_0;
11775         uint32_t _ptr_architecture;
11776         TALLOC_CTX *_mem_save_architecture_0;
11777         uint32_t _ptr_driver_path;
11778         TALLOC_CTX *_mem_save_driver_path_0;
11779         uint32_t _ptr_data_file;
11780         TALLOC_CTX *_mem_save_data_file_0;
11781         uint32_t _ptr_config_file;
11782         TALLOC_CTX *_mem_save_config_file_0;
11783         uint32_t _ptr_help_file;
11784         TALLOC_CTX *_mem_save_help_file_0;
11785         uint32_t _ptr_dependent_files;
11786         TALLOC_CTX *_mem_save_dependent_files_0;
11787         uint32_t _ptr_monitor_name;
11788         TALLOC_CTX *_mem_save_monitor_name_0;
11789         uint32_t _ptr_default_datatype;
11790         TALLOC_CTX *_mem_save_default_datatype_0;
11791         uint32_t _ptr_previous_names;
11792         TALLOC_CTX *_mem_save_previous_names_0;
11793         uint32_t _ptr_manufacturer_name;
11794         TALLOC_CTX *_mem_save_manufacturer_name_0;
11795         uint32_t _ptr_manufacturer_url;
11796         TALLOC_CTX *_mem_save_manufacturer_url_0;
11797         uint32_t _ptr_hardware_id;
11798         TALLOC_CTX *_mem_save_hardware_id_0;
11799         uint32_t _ptr_provider;
11800         TALLOC_CTX *_mem_save_provider_0;
11801         if (ndr_flags & NDR_SCALARS) {
11802                 NDR_CHECK(ndr_pull_align(ndr, 8));
11803                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11804                 {
11805                         uint32_t _flags_save_string = ndr->flags;
11806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11807                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11808                         if (_ptr_driver_name) {
11809                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11810                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11811                         } else {
11812                                 r->driver_name = NULL;
11813                         }
11814                         ndr->flags = _flags_save_string;
11815                 }
11816                 {
11817                         uint32_t _flags_save_string = ndr->flags;
11818                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11819                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11820                         if (_ptr_architecture) {
11821                                 NDR_PULL_ALLOC(ndr, r->architecture);
11822                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11823                         } else {
11824                                 r->architecture = NULL;
11825                         }
11826                         ndr->flags = _flags_save_string;
11827                 }
11828                 {
11829                         uint32_t _flags_save_string = ndr->flags;
11830                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11831                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11832                         if (_ptr_driver_path) {
11833                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11834                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11835                         } else {
11836                                 r->driver_path = NULL;
11837                         }
11838                         ndr->flags = _flags_save_string;
11839                 }
11840                 {
11841                         uint32_t _flags_save_string = ndr->flags;
11842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11843                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11844                         if (_ptr_data_file) {
11845                                 NDR_PULL_ALLOC(ndr, r->data_file);
11846                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11847                         } else {
11848                                 r->data_file = NULL;
11849                         }
11850                         ndr->flags = _flags_save_string;
11851                 }
11852                 {
11853                         uint32_t _flags_save_string = ndr->flags;
11854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11856                         if (_ptr_config_file) {
11857                                 NDR_PULL_ALLOC(ndr, r->config_file);
11858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11859                         } else {
11860                                 r->config_file = NULL;
11861                         }
11862                         ndr->flags = _flags_save_string;
11863                 }
11864                 {
11865                         uint32_t _flags_save_string = ndr->flags;
11866                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11867                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11868                         if (_ptr_help_file) {
11869                                 NDR_PULL_ALLOC(ndr, r->help_file);
11870                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11871                         } else {
11872                                 r->help_file = NULL;
11873                         }
11874                         ndr->flags = _flags_save_string;
11875                 }
11876                 {
11877                         uint32_t _flags_save_string_array = ndr->flags;
11878                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11879                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11880                         if (_ptr_dependent_files) {
11881                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11882                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11883                         } else {
11884                                 r->dependent_files = NULL;
11885                         }
11886                         ndr->flags = _flags_save_string_array;
11887                 }
11888                 {
11889                         uint32_t _flags_save_string = ndr->flags;
11890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11891                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11892                         if (_ptr_monitor_name) {
11893                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11894                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11895                         } else {
11896                                 r->monitor_name = NULL;
11897                         }
11898                         ndr->flags = _flags_save_string;
11899                 }
11900                 {
11901                         uint32_t _flags_save_string = ndr->flags;
11902                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11903                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11904                         if (_ptr_default_datatype) {
11905                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11906                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11907                         } else {
11908                                 r->default_datatype = NULL;
11909                         }
11910                         ndr->flags = _flags_save_string;
11911                 }
11912                 {
11913                         uint32_t _flags_save_string_array = ndr->flags;
11914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11915                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11916                         if (_ptr_previous_names) {
11917                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11918                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11919                         } else {
11920                                 r->previous_names = NULL;
11921                         }
11922                         ndr->flags = _flags_save_string_array;
11923                 }
11924                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11925                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11926                 {
11927                         uint32_t _flags_save_string = ndr->flags;
11928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11929                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11930                         if (_ptr_manufacturer_name) {
11931                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11932                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11933                         } else {
11934                                 r->manufacturer_name = NULL;
11935                         }
11936                         ndr->flags = _flags_save_string;
11937                 }
11938                 {
11939                         uint32_t _flags_save_string = ndr->flags;
11940                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11941                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11942                         if (_ptr_manufacturer_url) {
11943                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11944                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11945                         } else {
11946                                 r->manufacturer_url = NULL;
11947                         }
11948                         ndr->flags = _flags_save_string;
11949                 }
11950                 {
11951                         uint32_t _flags_save_string = ndr->flags;
11952                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11953                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11954                         if (_ptr_hardware_id) {
11955                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11956                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11957                         } else {
11958                                 r->hardware_id = NULL;
11959                         }
11960                         ndr->flags = _flags_save_string;
11961                 }
11962                 {
11963                         uint32_t _flags_save_string = ndr->flags;
11964                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11965                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11966                         if (_ptr_provider) {
11967                                 NDR_PULL_ALLOC(ndr, r->provider);
11968                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11969                         } else {
11970                                 r->provider = NULL;
11971                         }
11972                         ndr->flags = _flags_save_string;
11973                 }
11974         }
11975         if (ndr_flags & NDR_BUFFERS) {
11976                 {
11977                         uint32_t _flags_save_string = ndr->flags;
11978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11979                         if (r->driver_name) {
11980                                 uint32_t _relative_save_offset;
11981                                 _relative_save_offset = ndr->offset;
11982                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11983                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11984                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11985                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11986                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11987                                 ndr->offset = _relative_save_offset;
11988                         }
11989                         ndr->flags = _flags_save_string;
11990                 }
11991                 {
11992                         uint32_t _flags_save_string = ndr->flags;
11993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11994                         if (r->architecture) {
11995                                 uint32_t _relative_save_offset;
11996                                 _relative_save_offset = ndr->offset;
11997                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11998                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11999                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12000                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12001                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12002                                 ndr->offset = _relative_save_offset;
12003                         }
12004                         ndr->flags = _flags_save_string;
12005                 }
12006                 {
12007                         uint32_t _flags_save_string = ndr->flags;
12008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12009                         if (r->driver_path) {
12010                                 uint32_t _relative_save_offset;
12011                                 _relative_save_offset = ndr->offset;
12012                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12013                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12014                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12015                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12016                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12017                                 ndr->offset = _relative_save_offset;
12018                         }
12019                         ndr->flags = _flags_save_string;
12020                 }
12021                 {
12022                         uint32_t _flags_save_string = ndr->flags;
12023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12024                         if (r->data_file) {
12025                                 uint32_t _relative_save_offset;
12026                                 _relative_save_offset = ndr->offset;
12027                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12028                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12029                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12030                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12031                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12032                                 ndr->offset = _relative_save_offset;
12033                         }
12034                         ndr->flags = _flags_save_string;
12035                 }
12036                 {
12037                         uint32_t _flags_save_string = ndr->flags;
12038                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12039                         if (r->config_file) {
12040                                 uint32_t _relative_save_offset;
12041                                 _relative_save_offset = ndr->offset;
12042                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12043                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12044                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12045                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12046                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12047                                 ndr->offset = _relative_save_offset;
12048                         }
12049                         ndr->flags = _flags_save_string;
12050                 }
12051                 {
12052                         uint32_t _flags_save_string = ndr->flags;
12053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12054                         if (r->help_file) {
12055                                 uint32_t _relative_save_offset;
12056                                 _relative_save_offset = ndr->offset;
12057                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12058                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12059                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12060                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12061                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12062                                 ndr->offset = _relative_save_offset;
12063                         }
12064                         ndr->flags = _flags_save_string;
12065                 }
12066                 {
12067                         uint32_t _flags_save_string_array = ndr->flags;
12068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12069                         if (r->dependent_files) {
12070                                 uint32_t _relative_save_offset;
12071                                 _relative_save_offset = ndr->offset;
12072                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12073                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12074                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12075                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12076                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12077                                 ndr->offset = _relative_save_offset;
12078                         }
12079                         ndr->flags = _flags_save_string_array;
12080                 }
12081                 {
12082                         uint32_t _flags_save_string = ndr->flags;
12083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12084                         if (r->monitor_name) {
12085                                 uint32_t _relative_save_offset;
12086                                 _relative_save_offset = ndr->offset;
12087                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12088                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12089                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12090                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12091                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12092                                 ndr->offset = _relative_save_offset;
12093                         }
12094                         ndr->flags = _flags_save_string;
12095                 }
12096                 {
12097                         uint32_t _flags_save_string = ndr->flags;
12098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12099                         if (r->default_datatype) {
12100                                 uint32_t _relative_save_offset;
12101                                 _relative_save_offset = ndr->offset;
12102                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12103                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12104                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12105                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12106                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12107                                 ndr->offset = _relative_save_offset;
12108                         }
12109                         ndr->flags = _flags_save_string;
12110                 }
12111                 {
12112                         uint32_t _flags_save_string_array = ndr->flags;
12113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12114                         if (r->previous_names) {
12115                                 uint32_t _relative_save_offset;
12116                                 _relative_save_offset = ndr->offset;
12117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12118                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12119                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12120                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12122                                 ndr->offset = _relative_save_offset;
12123                         }
12124                         ndr->flags = _flags_save_string_array;
12125                 }
12126                 {
12127                         uint32_t _flags_save_string = ndr->flags;
12128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12129                         if (r->manufacturer_name) {
12130                                 uint32_t _relative_save_offset;
12131                                 _relative_save_offset = ndr->offset;
12132                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12133                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12134                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12135                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12136                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12137                                 ndr->offset = _relative_save_offset;
12138                         }
12139                         ndr->flags = _flags_save_string;
12140                 }
12141                 {
12142                         uint32_t _flags_save_string = ndr->flags;
12143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12144                         if (r->manufacturer_url) {
12145                                 uint32_t _relative_save_offset;
12146                                 _relative_save_offset = ndr->offset;
12147                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12148                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12149                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12150                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12151                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12152                                 ndr->offset = _relative_save_offset;
12153                         }
12154                         ndr->flags = _flags_save_string;
12155                 }
12156                 {
12157                         uint32_t _flags_save_string = ndr->flags;
12158                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12159                         if (r->hardware_id) {
12160                                 uint32_t _relative_save_offset;
12161                                 _relative_save_offset = ndr->offset;
12162                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12163                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12164                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12165                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12166                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12167                                 ndr->offset = _relative_save_offset;
12168                         }
12169                         ndr->flags = _flags_save_string;
12170                 }
12171                 {
12172                         uint32_t _flags_save_string = ndr->flags;
12173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12174                         if (r->provider) {
12175                                 uint32_t _relative_save_offset;
12176                                 _relative_save_offset = ndr->offset;
12177                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12178                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12179                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12180                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12181                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12182                                 ndr->offset = _relative_save_offset;
12183                         }
12184                         ndr->flags = _flags_save_string;
12185                 }
12186         }
12187         return NDR_ERR_SUCCESS;
12188 }
12189
12190 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12191 {
12192         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12193         ndr->depth++;
12194         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12195         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12196         ndr->depth++;
12197         if (r->driver_name) {
12198                 ndr_print_string(ndr, "driver_name", r->driver_name);
12199         }
12200         ndr->depth--;
12201         ndr_print_ptr(ndr, "architecture", r->architecture);
12202         ndr->depth++;
12203         if (r->architecture) {
12204                 ndr_print_string(ndr, "architecture", r->architecture);
12205         }
12206         ndr->depth--;
12207         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12208         ndr->depth++;
12209         if (r->driver_path) {
12210                 ndr_print_string(ndr, "driver_path", r->driver_path);
12211         }
12212         ndr->depth--;
12213         ndr_print_ptr(ndr, "data_file", r->data_file);
12214         ndr->depth++;
12215         if (r->data_file) {
12216                 ndr_print_string(ndr, "data_file", r->data_file);
12217         }
12218         ndr->depth--;
12219         ndr_print_ptr(ndr, "config_file", r->config_file);
12220         ndr->depth++;
12221         if (r->config_file) {
12222                 ndr_print_string(ndr, "config_file", r->config_file);
12223         }
12224         ndr->depth--;
12225         ndr_print_ptr(ndr, "help_file", r->help_file);
12226         ndr->depth++;
12227         if (r->help_file) {
12228                 ndr_print_string(ndr, "help_file", r->help_file);
12229         }
12230         ndr->depth--;
12231         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12232         ndr->depth++;
12233         if (r->dependent_files) {
12234                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12235         }
12236         ndr->depth--;
12237         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12238         ndr->depth++;
12239         if (r->monitor_name) {
12240                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12241         }
12242         ndr->depth--;
12243         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12244         ndr->depth++;
12245         if (r->default_datatype) {
12246                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12247         }
12248         ndr->depth--;
12249         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12250         ndr->depth++;
12251         if (r->previous_names) {
12252                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12253         }
12254         ndr->depth--;
12255         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12256         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12257         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12258         ndr->depth++;
12259         if (r->manufacturer_name) {
12260                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12261         }
12262         ndr->depth--;
12263         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12264         ndr->depth++;
12265         if (r->manufacturer_url) {
12266                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12267         }
12268         ndr->depth--;
12269         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12270         ndr->depth++;
12271         if (r->hardware_id) {
12272                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12273         }
12274         ndr->depth--;
12275         ndr_print_ptr(ndr, "provider", r->provider);
12276         ndr->depth++;
12277         if (r->provider) {
12278                 ndr_print_string(ndr, "provider", r->provider);
12279         }
12280         ndr->depth--;
12281         ndr->depth--;
12282 }
12283
12284 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12285 {
12286         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12287 }
12288
12289 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12290 {
12291         if (ndr_flags & NDR_SCALARS) {
12292                 NDR_CHECK(ndr_push_align(ndr, 8));
12293                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12294                 {
12295                         uint32_t _flags_save_string = ndr->flags;
12296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12297                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12298                         ndr->flags = _flags_save_string;
12299                 }
12300                 {
12301                         uint32_t _flags_save_string = ndr->flags;
12302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12303                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12304                         ndr->flags = _flags_save_string;
12305                 }
12306                 {
12307                         uint32_t _flags_save_string = ndr->flags;
12308                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12309                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12310                         ndr->flags = _flags_save_string;
12311                 }
12312                 {
12313                         uint32_t _flags_save_string = ndr->flags;
12314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12315                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12316                         ndr->flags = _flags_save_string;
12317                 }
12318                 {
12319                         uint32_t _flags_save_string = ndr->flags;
12320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12321                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12322                         ndr->flags = _flags_save_string;
12323                 }
12324                 {
12325                         uint32_t _flags_save_string = ndr->flags;
12326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12327                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12328                         ndr->flags = _flags_save_string;
12329                 }
12330                 {
12331                         uint32_t _flags_save_string = ndr->flags;
12332                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12333                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12334                         ndr->flags = _flags_save_string;
12335                 }
12336                 {
12337                         uint32_t _flags_save_string = ndr->flags;
12338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12339                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12340                         ndr->flags = _flags_save_string;
12341                 }
12342                 {
12343                         uint32_t _flags_save_string_array = ndr->flags;
12344                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12345                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12346                         ndr->flags = _flags_save_string_array;
12347                 }
12348                 {
12349                         uint32_t _flags_save_string_array = ndr->flags;
12350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12351                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12352                         ndr->flags = _flags_save_string_array;
12353                 }
12354                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12355                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12356                 {
12357                         uint32_t _flags_save_string = ndr->flags;
12358                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12359                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12360                         ndr->flags = _flags_save_string;
12361                 }
12362                 {
12363                         uint32_t _flags_save_string = ndr->flags;
12364                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12365                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12366                         ndr->flags = _flags_save_string;
12367                 }
12368                 {
12369                         uint32_t _flags_save_string = ndr->flags;
12370                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12371                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12372                         ndr->flags = _flags_save_string;
12373                 }
12374                 {
12375                         uint32_t _flags_save_string = ndr->flags;
12376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12377                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12378                         ndr->flags = _flags_save_string;
12379                 }
12380                 {
12381                         uint32_t _flags_save_string = ndr->flags;
12382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12383                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12384                         ndr->flags = _flags_save_string;
12385                 }
12386                 {
12387                         uint32_t _flags_save_string = ndr->flags;
12388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12389                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12390                         ndr->flags = _flags_save_string;
12391                 }
12392                 {
12393                         uint32_t _flags_save_string_array = ndr->flags;
12394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12395                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12396                         ndr->flags = _flags_save_string_array;
12397                 }
12398                 {
12399                         uint32_t _flags_save_string = ndr->flags;
12400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12401                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12402                         ndr->flags = _flags_save_string;
12403                 }
12404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12405                 {
12406                         uint32_t _flags_save_string_array = ndr->flags;
12407                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12408                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12409                         ndr->flags = _flags_save_string_array;
12410                 }
12411                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12412                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12413         }
12414         if (ndr_flags & NDR_BUFFERS) {
12415                 {
12416                         uint32_t _flags_save_string = ndr->flags;
12417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12418                         if (r->driver_name) {
12419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
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->architecture) {
12428                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12429                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
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->driver_path) {
12437                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12438                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
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->data_file) {
12446                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12447                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_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->config_file) {
12455                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12456                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_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->help_file) {
12464                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12465                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
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->monitor_name) {
12473                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12474                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12475                         }
12476                         ndr->flags = _flags_save_string;
12477                 }
12478                 {
12479                         uint32_t _flags_save_string = ndr->flags;
12480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12481                         if (r->default_datatype) {
12482                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12483                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12484                         }
12485                         ndr->flags = _flags_save_string;
12486                 }
12487                 {
12488                         uint32_t _flags_save_string_array = ndr->flags;
12489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12490                         if (r->dependent_files) {
12491                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12492                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12493                         }
12494                         ndr->flags = _flags_save_string_array;
12495                 }
12496                 {
12497                         uint32_t _flags_save_string_array = ndr->flags;
12498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12499                         if (r->previous_names) {
12500                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12501                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12502                         }
12503                         ndr->flags = _flags_save_string_array;
12504                 }
12505                 {
12506                         uint32_t _flags_save_string = ndr->flags;
12507                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12508                         if (r->manufacturer_name) {
12509                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12510                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
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->manufacturer_url) {
12518                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12519                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
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->hardware_id) {
12527                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12528                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
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->provider) {
12536                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12537                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
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->print_processor) {
12545                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12546                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12547                         }
12548                         ndr->flags = _flags_save_string;
12549                 }
12550                 {
12551                         uint32_t _flags_save_string = ndr->flags;
12552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12553                         if (r->vendor_setup) {
12554                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12555                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12556                         }
12557                         ndr->flags = _flags_save_string;
12558                 }
12559                 {
12560                         uint32_t _flags_save_string_array = ndr->flags;
12561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12562                         if (r->color_profiles) {
12563                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12564                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12565                         }
12566                         ndr->flags = _flags_save_string_array;
12567                 }
12568                 {
12569                         uint32_t _flags_save_string = ndr->flags;
12570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12571                         if (r->inf_path) {
12572                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12573                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12574                         }
12575                         ndr->flags = _flags_save_string;
12576                 }
12577                 {
12578                         uint32_t _flags_save_string_array = ndr->flags;
12579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12580                         if (r->core_driver_dependencies) {
12581                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12582                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12583                         }
12584                         ndr->flags = _flags_save_string_array;
12585                 }
12586         }
12587         return NDR_ERR_SUCCESS;
12588 }
12589
12590 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12591 {
12592         uint32_t _ptr_driver_name;
12593         TALLOC_CTX *_mem_save_driver_name_0;
12594         uint32_t _ptr_architecture;
12595         TALLOC_CTX *_mem_save_architecture_0;
12596         uint32_t _ptr_driver_path;
12597         TALLOC_CTX *_mem_save_driver_path_0;
12598         uint32_t _ptr_data_file;
12599         TALLOC_CTX *_mem_save_data_file_0;
12600         uint32_t _ptr_config_file;
12601         TALLOC_CTX *_mem_save_config_file_0;
12602         uint32_t _ptr_help_file;
12603         TALLOC_CTX *_mem_save_help_file_0;
12604         uint32_t _ptr_monitor_name;
12605         TALLOC_CTX *_mem_save_monitor_name_0;
12606         uint32_t _ptr_default_datatype;
12607         TALLOC_CTX *_mem_save_default_datatype_0;
12608         uint32_t _ptr_dependent_files;
12609         TALLOC_CTX *_mem_save_dependent_files_0;
12610         uint32_t _ptr_previous_names;
12611         TALLOC_CTX *_mem_save_previous_names_0;
12612         uint32_t _ptr_manufacturer_name;
12613         TALLOC_CTX *_mem_save_manufacturer_name_0;
12614         uint32_t _ptr_manufacturer_url;
12615         TALLOC_CTX *_mem_save_manufacturer_url_0;
12616         uint32_t _ptr_hardware_id;
12617         TALLOC_CTX *_mem_save_hardware_id_0;
12618         uint32_t _ptr_provider;
12619         TALLOC_CTX *_mem_save_provider_0;
12620         uint32_t _ptr_print_processor;
12621         TALLOC_CTX *_mem_save_print_processor_0;
12622         uint32_t _ptr_vendor_setup;
12623         TALLOC_CTX *_mem_save_vendor_setup_0;
12624         uint32_t _ptr_color_profiles;
12625         TALLOC_CTX *_mem_save_color_profiles_0;
12626         uint32_t _ptr_inf_path;
12627         TALLOC_CTX *_mem_save_inf_path_0;
12628         uint32_t _ptr_core_driver_dependencies;
12629         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12630         if (ndr_flags & NDR_SCALARS) {
12631                 NDR_CHECK(ndr_pull_align(ndr, 8));
12632                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12633                 {
12634                         uint32_t _flags_save_string = ndr->flags;
12635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12636                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12637                         if (_ptr_driver_name) {
12638                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12639                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12640                         } else {
12641                                 r->driver_name = NULL;
12642                         }
12643                         ndr->flags = _flags_save_string;
12644                 }
12645                 {
12646                         uint32_t _flags_save_string = ndr->flags;
12647                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12648                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12649                         if (_ptr_architecture) {
12650                                 NDR_PULL_ALLOC(ndr, r->architecture);
12651                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12652                         } else {
12653                                 r->architecture = NULL;
12654                         }
12655                         ndr->flags = _flags_save_string;
12656                 }
12657                 {
12658                         uint32_t _flags_save_string = ndr->flags;
12659                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12660                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12661                         if (_ptr_driver_path) {
12662                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12663                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12664                         } else {
12665                                 r->driver_path = NULL;
12666                         }
12667                         ndr->flags = _flags_save_string;
12668                 }
12669                 {
12670                         uint32_t _flags_save_string = ndr->flags;
12671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12672                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12673                         if (_ptr_data_file) {
12674                                 NDR_PULL_ALLOC(ndr, r->data_file);
12675                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12676                         } else {
12677                                 r->data_file = NULL;
12678                         }
12679                         ndr->flags = _flags_save_string;
12680                 }
12681                 {
12682                         uint32_t _flags_save_string = ndr->flags;
12683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12684                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12685                         if (_ptr_config_file) {
12686                                 NDR_PULL_ALLOC(ndr, r->config_file);
12687                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12688                         } else {
12689                                 r->config_file = NULL;
12690                         }
12691                         ndr->flags = _flags_save_string;
12692                 }
12693                 {
12694                         uint32_t _flags_save_string = ndr->flags;
12695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12696                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12697                         if (_ptr_help_file) {
12698                                 NDR_PULL_ALLOC(ndr, r->help_file);
12699                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12700                         } else {
12701                                 r->help_file = NULL;
12702                         }
12703                         ndr->flags = _flags_save_string;
12704                 }
12705                 {
12706                         uint32_t _flags_save_string = ndr->flags;
12707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12708                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12709                         if (_ptr_monitor_name) {
12710                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12711                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12712                         } else {
12713                                 r->monitor_name = NULL;
12714                         }
12715                         ndr->flags = _flags_save_string;
12716                 }
12717                 {
12718                         uint32_t _flags_save_string = ndr->flags;
12719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12720                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12721                         if (_ptr_default_datatype) {
12722                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12723                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12724                         } else {
12725                                 r->default_datatype = NULL;
12726                         }
12727                         ndr->flags = _flags_save_string;
12728                 }
12729                 {
12730                         uint32_t _flags_save_string_array = ndr->flags;
12731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12732                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12733                         if (_ptr_dependent_files) {
12734                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12736                         } else {
12737                                 r->dependent_files = NULL;
12738                         }
12739                         ndr->flags = _flags_save_string_array;
12740                 }
12741                 {
12742                         uint32_t _flags_save_string_array = ndr->flags;
12743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12745                         if (_ptr_previous_names) {
12746                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12748                         } else {
12749                                 r->previous_names = NULL;
12750                         }
12751                         ndr->flags = _flags_save_string_array;
12752                 }
12753                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12754                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12755                 {
12756                         uint32_t _flags_save_string = ndr->flags;
12757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12758                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12759                         if (_ptr_manufacturer_name) {
12760                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12761                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12762                         } else {
12763                                 r->manufacturer_name = NULL;
12764                         }
12765                         ndr->flags = _flags_save_string;
12766                 }
12767                 {
12768                         uint32_t _flags_save_string = ndr->flags;
12769                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12770                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12771                         if (_ptr_manufacturer_url) {
12772                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12773                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12774                         } else {
12775                                 r->manufacturer_url = NULL;
12776                         }
12777                         ndr->flags = _flags_save_string;
12778                 }
12779                 {
12780                         uint32_t _flags_save_string = ndr->flags;
12781                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12782                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12783                         if (_ptr_hardware_id) {
12784                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12785                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12786                         } else {
12787                                 r->hardware_id = NULL;
12788                         }
12789                         ndr->flags = _flags_save_string;
12790                 }
12791                 {
12792                         uint32_t _flags_save_string = ndr->flags;
12793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12794                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12795                         if (_ptr_provider) {
12796                                 NDR_PULL_ALLOC(ndr, r->provider);
12797                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12798                         } else {
12799                                 r->provider = NULL;
12800                         }
12801                         ndr->flags = _flags_save_string;
12802                 }
12803                 {
12804                         uint32_t _flags_save_string = ndr->flags;
12805                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12806                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12807                         if (_ptr_print_processor) {
12808                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12809                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12810                         } else {
12811                                 r->print_processor = NULL;
12812                         }
12813                         ndr->flags = _flags_save_string;
12814                 }
12815                 {
12816                         uint32_t _flags_save_string = ndr->flags;
12817                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12818                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12819                         if (_ptr_vendor_setup) {
12820                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12821                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12822                         } else {
12823                                 r->vendor_setup = NULL;
12824                         }
12825                         ndr->flags = _flags_save_string;
12826                 }
12827                 {
12828                         uint32_t _flags_save_string_array = ndr->flags;
12829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12830                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12831                         if (_ptr_color_profiles) {
12832                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12833                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12834                         } else {
12835                                 r->color_profiles = NULL;
12836                         }
12837                         ndr->flags = _flags_save_string_array;
12838                 }
12839                 {
12840                         uint32_t _flags_save_string = ndr->flags;
12841                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12842                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12843                         if (_ptr_inf_path) {
12844                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12845                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12846                         } else {
12847                                 r->inf_path = NULL;
12848                         }
12849                         ndr->flags = _flags_save_string;
12850                 }
12851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12852                 {
12853                         uint32_t _flags_save_string_array = ndr->flags;
12854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12855                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12856                         if (_ptr_core_driver_dependencies) {
12857                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12858                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12859                         } else {
12860                                 r->core_driver_dependencies = NULL;
12861                         }
12862                         ndr->flags = _flags_save_string_array;
12863                 }
12864                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12865                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12866         }
12867         if (ndr_flags & NDR_BUFFERS) {
12868                 {
12869                         uint32_t _flags_save_string = ndr->flags;
12870                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12871                         if (r->driver_name) {
12872                                 uint32_t _relative_save_offset;
12873                                 _relative_save_offset = ndr->offset;
12874                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12875                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12876                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12877                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12878                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12879                                 ndr->offset = _relative_save_offset;
12880                         }
12881                         ndr->flags = _flags_save_string;
12882                 }
12883                 {
12884                         uint32_t _flags_save_string = ndr->flags;
12885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12886                         if (r->architecture) {
12887                                 uint32_t _relative_save_offset;
12888                                 _relative_save_offset = ndr->offset;
12889                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12890                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12891                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12892                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12893                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12894                                 ndr->offset = _relative_save_offset;
12895                         }
12896                         ndr->flags = _flags_save_string;
12897                 }
12898                 {
12899                         uint32_t _flags_save_string = ndr->flags;
12900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12901                         if (r->driver_path) {
12902                                 uint32_t _relative_save_offset;
12903                                 _relative_save_offset = ndr->offset;
12904                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12905                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12906                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12907                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12908                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12909                                 ndr->offset = _relative_save_offset;
12910                         }
12911                         ndr->flags = _flags_save_string;
12912                 }
12913                 {
12914                         uint32_t _flags_save_string = ndr->flags;
12915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12916                         if (r->data_file) {
12917                                 uint32_t _relative_save_offset;
12918                                 _relative_save_offset = ndr->offset;
12919                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12920                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12921                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12922                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12923                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12924                                 ndr->offset = _relative_save_offset;
12925                         }
12926                         ndr->flags = _flags_save_string;
12927                 }
12928                 {
12929                         uint32_t _flags_save_string = ndr->flags;
12930                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12931                         if (r->config_file) {
12932                                 uint32_t _relative_save_offset;
12933                                 _relative_save_offset = ndr->offset;
12934                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12935                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12936                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12937                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12938                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12939                                 ndr->offset = _relative_save_offset;
12940                         }
12941                         ndr->flags = _flags_save_string;
12942                 }
12943                 {
12944                         uint32_t _flags_save_string = ndr->flags;
12945                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12946                         if (r->help_file) {
12947                                 uint32_t _relative_save_offset;
12948                                 _relative_save_offset = ndr->offset;
12949                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12950                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12951                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12952                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12953                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12954                                 ndr->offset = _relative_save_offset;
12955                         }
12956                         ndr->flags = _flags_save_string;
12957                 }
12958                 {
12959                         uint32_t _flags_save_string = ndr->flags;
12960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12961                         if (r->monitor_name) {
12962                                 uint32_t _relative_save_offset;
12963                                 _relative_save_offset = ndr->offset;
12964                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12965                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12966                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12967                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12968                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12969                                 ndr->offset = _relative_save_offset;
12970                         }
12971                         ndr->flags = _flags_save_string;
12972                 }
12973                 {
12974                         uint32_t _flags_save_string = ndr->flags;
12975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12976                         if (r->default_datatype) {
12977                                 uint32_t _relative_save_offset;
12978                                 _relative_save_offset = ndr->offset;
12979                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12980                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12981                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12982                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12983                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12984                                 ndr->offset = _relative_save_offset;
12985                         }
12986                         ndr->flags = _flags_save_string;
12987                 }
12988                 {
12989                         uint32_t _flags_save_string_array = ndr->flags;
12990                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12991                         if (r->dependent_files) {
12992                                 uint32_t _relative_save_offset;
12993                                 _relative_save_offset = ndr->offset;
12994                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12995                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12996                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12997                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12998                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12999                                 ndr->offset = _relative_save_offset;
13000                         }
13001                         ndr->flags = _flags_save_string_array;
13002                 }
13003                 {
13004                         uint32_t _flags_save_string_array = ndr->flags;
13005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13006                         if (r->previous_names) {
13007                                 uint32_t _relative_save_offset;
13008                                 _relative_save_offset = ndr->offset;
13009                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13010                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13011                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13012                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13013                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13014                                 ndr->offset = _relative_save_offset;
13015                         }
13016                         ndr->flags = _flags_save_string_array;
13017                 }
13018                 {
13019                         uint32_t _flags_save_string = ndr->flags;
13020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13021                         if (r->manufacturer_name) {
13022                                 uint32_t _relative_save_offset;
13023                                 _relative_save_offset = ndr->offset;
13024                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13025                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13026                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13027                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13028                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13029                                 ndr->offset = _relative_save_offset;
13030                         }
13031                         ndr->flags = _flags_save_string;
13032                 }
13033                 {
13034                         uint32_t _flags_save_string = ndr->flags;
13035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13036                         if (r->manufacturer_url) {
13037                                 uint32_t _relative_save_offset;
13038                                 _relative_save_offset = ndr->offset;
13039                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13040                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13041                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13042                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13043                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13044                                 ndr->offset = _relative_save_offset;
13045                         }
13046                         ndr->flags = _flags_save_string;
13047                 }
13048                 {
13049                         uint32_t _flags_save_string = ndr->flags;
13050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13051                         if (r->hardware_id) {
13052                                 uint32_t _relative_save_offset;
13053                                 _relative_save_offset = ndr->offset;
13054                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13055                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13056                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13057                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13058                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13059                                 ndr->offset = _relative_save_offset;
13060                         }
13061                         ndr->flags = _flags_save_string;
13062                 }
13063                 {
13064                         uint32_t _flags_save_string = ndr->flags;
13065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13066                         if (r->provider) {
13067                                 uint32_t _relative_save_offset;
13068                                 _relative_save_offset = ndr->offset;
13069                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13070                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13071                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13072                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13073                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13074                                 ndr->offset = _relative_save_offset;
13075                         }
13076                         ndr->flags = _flags_save_string;
13077                 }
13078                 {
13079                         uint32_t _flags_save_string = ndr->flags;
13080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13081                         if (r->print_processor) {
13082                                 uint32_t _relative_save_offset;
13083                                 _relative_save_offset = ndr->offset;
13084                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13085                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13086                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13087                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13088                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13089                                 ndr->offset = _relative_save_offset;
13090                         }
13091                         ndr->flags = _flags_save_string;
13092                 }
13093                 {
13094                         uint32_t _flags_save_string = ndr->flags;
13095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13096                         if (r->vendor_setup) {
13097                                 uint32_t _relative_save_offset;
13098                                 _relative_save_offset = ndr->offset;
13099                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13100                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13101                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13102                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13103                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13104                                 ndr->offset = _relative_save_offset;
13105                         }
13106                         ndr->flags = _flags_save_string;
13107                 }
13108                 {
13109                         uint32_t _flags_save_string_array = ndr->flags;
13110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13111                         if (r->color_profiles) {
13112                                 uint32_t _relative_save_offset;
13113                                 _relative_save_offset = ndr->offset;
13114                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13115                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13116                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13117                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13118                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13119                                 ndr->offset = _relative_save_offset;
13120                         }
13121                         ndr->flags = _flags_save_string_array;
13122                 }
13123                 {
13124                         uint32_t _flags_save_string = ndr->flags;
13125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13126                         if (r->inf_path) {
13127                                 uint32_t _relative_save_offset;
13128                                 _relative_save_offset = ndr->offset;
13129                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13130                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13131                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13132                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13133                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13134                                 ndr->offset = _relative_save_offset;
13135                         }
13136                         ndr->flags = _flags_save_string;
13137                 }
13138                 {
13139                         uint32_t _flags_save_string_array = ndr->flags;
13140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13141                         if (r->core_driver_dependencies) {
13142                                 uint32_t _relative_save_offset;
13143                                 _relative_save_offset = ndr->offset;
13144                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13145                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13146                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13147                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13148                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13149                                 ndr->offset = _relative_save_offset;
13150                         }
13151                         ndr->flags = _flags_save_string_array;
13152                 }
13153         }
13154         return NDR_ERR_SUCCESS;
13155 }
13156
13157 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13158 {
13159         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13160         ndr->depth++;
13161         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13162         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13163         ndr->depth++;
13164         if (r->driver_name) {
13165                 ndr_print_string(ndr, "driver_name", r->driver_name);
13166         }
13167         ndr->depth--;
13168         ndr_print_ptr(ndr, "architecture", r->architecture);
13169         ndr->depth++;
13170         if (r->architecture) {
13171                 ndr_print_string(ndr, "architecture", r->architecture);
13172         }
13173         ndr->depth--;
13174         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13175         ndr->depth++;
13176         if (r->driver_path) {
13177                 ndr_print_string(ndr, "driver_path", r->driver_path);
13178         }
13179         ndr->depth--;
13180         ndr_print_ptr(ndr, "data_file", r->data_file);
13181         ndr->depth++;
13182         if (r->data_file) {
13183                 ndr_print_string(ndr, "data_file", r->data_file);
13184         }
13185         ndr->depth--;
13186         ndr_print_ptr(ndr, "config_file", r->config_file);
13187         ndr->depth++;
13188         if (r->config_file) {
13189                 ndr_print_string(ndr, "config_file", r->config_file);
13190         }
13191         ndr->depth--;
13192         ndr_print_ptr(ndr, "help_file", r->help_file);
13193         ndr->depth++;
13194         if (r->help_file) {
13195                 ndr_print_string(ndr, "help_file", r->help_file);
13196         }
13197         ndr->depth--;
13198         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13199         ndr->depth++;
13200         if (r->monitor_name) {
13201                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13202         }
13203         ndr->depth--;
13204         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13205         ndr->depth++;
13206         if (r->default_datatype) {
13207                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13208         }
13209         ndr->depth--;
13210         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13211         ndr->depth++;
13212         if (r->dependent_files) {
13213                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13214         }
13215         ndr->depth--;
13216         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13217         ndr->depth++;
13218         if (r->previous_names) {
13219                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13220         }
13221         ndr->depth--;
13222         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13223         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13224         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13225         ndr->depth++;
13226         if (r->manufacturer_name) {
13227                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13228         }
13229         ndr->depth--;
13230         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13231         ndr->depth++;
13232         if (r->manufacturer_url) {
13233                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13234         }
13235         ndr->depth--;
13236         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13237         ndr->depth++;
13238         if (r->hardware_id) {
13239                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13240         }
13241         ndr->depth--;
13242         ndr_print_ptr(ndr, "provider", r->provider);
13243         ndr->depth++;
13244         if (r->provider) {
13245                 ndr_print_string(ndr, "provider", r->provider);
13246         }
13247         ndr->depth--;
13248         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13249         ndr->depth++;
13250         if (r->print_processor) {
13251                 ndr_print_string(ndr, "print_processor", r->print_processor);
13252         }
13253         ndr->depth--;
13254         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13255         ndr->depth++;
13256         if (r->vendor_setup) {
13257                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13258         }
13259         ndr->depth--;
13260         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13261         ndr->depth++;
13262         if (r->color_profiles) {
13263                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13264         }
13265         ndr->depth--;
13266         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13267         ndr->depth++;
13268         if (r->inf_path) {
13269                 ndr_print_string(ndr, "inf_path", r->inf_path);
13270         }
13271         ndr->depth--;
13272         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13273         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13274         ndr->depth++;
13275         if (r->core_driver_dependencies) {
13276                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13277         }
13278         ndr->depth--;
13279         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13280         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13281         ndr->depth--;
13282 }
13283
13284 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13285 {
13286         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13287 }
13288
13289 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13290 {
13291         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13292         return NDR_ERR_SUCCESS;
13293 }
13294
13295 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13296 {
13297         uint32_t v;
13298         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13299         *r = v;
13300         return NDR_ERR_SUCCESS;
13301 }
13302
13303 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13304 {
13305         const char *val = NULL;
13306
13307         switch (r) {
13308                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13309                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13310                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13311                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13312                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13313         }
13314         ndr_print_enum(ndr, name, "ENUM", val, r);
13315 }
13316
13317 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13318 {
13319         if (ndr_flags & NDR_SCALARS) {
13320                 NDR_CHECK(ndr_push_align(ndr, 4));
13321                 {
13322                         uint32_t _flags_save_string = ndr->flags;
13323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13325                         ndr->flags = _flags_save_string;
13326                 }
13327                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13329         }
13330         if (ndr_flags & NDR_BUFFERS) {
13331                 {
13332                         uint32_t _flags_save_string = ndr->flags;
13333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13334                         if (r->file_name) {
13335                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13336                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13337                         }
13338                         ndr->flags = _flags_save_string;
13339                 }
13340         }
13341         return NDR_ERR_SUCCESS;
13342 }
13343
13344 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13345 {
13346         uint32_t _ptr_file_name;
13347         TALLOC_CTX *_mem_save_file_name_0;
13348         if (ndr_flags & NDR_SCALARS) {
13349                 NDR_CHECK(ndr_pull_align(ndr, 4));
13350                 {
13351                         uint32_t _flags_save_string = ndr->flags;
13352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13353                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13354                         if (_ptr_file_name) {
13355                                 NDR_PULL_ALLOC(ndr, r->file_name);
13356                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13357                         } else {
13358                                 r->file_name = NULL;
13359                         }
13360                         ndr->flags = _flags_save_string;
13361                 }
13362                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13364         }
13365         if (ndr_flags & NDR_BUFFERS) {
13366                 {
13367                         uint32_t _flags_save_string = ndr->flags;
13368                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13369                         if (r->file_name) {
13370                                 uint32_t _relative_save_offset;
13371                                 _relative_save_offset = ndr->offset;
13372                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13373                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13374                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13375                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13376                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13377                                 ndr->offset = _relative_save_offset;
13378                         }
13379                         ndr->flags = _flags_save_string;
13380                 }
13381         }
13382         return NDR_ERR_SUCCESS;
13383 }
13384
13385 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13386 {
13387         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13388         ndr->depth++;
13389         ndr_print_ptr(ndr, "file_name", r->file_name);
13390         ndr->depth++;
13391         if (r->file_name) {
13392                 ndr_print_string(ndr, "file_name", r->file_name);
13393         }
13394         ndr->depth--;
13395         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13396         ndr_print_uint32(ndr, "file_version", r->file_version);
13397         ndr->depth--;
13398 }
13399
13400 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13401 {
13402         uint32_t cntr_file_info_1;
13403         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13404         ndr->depth++;
13405         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13406         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13407         ndr->depth++;
13408         if (r->driver_name) {
13409                 ndr_print_string(ndr, "driver_name", r->driver_name);
13410         }
13411         ndr->depth--;
13412         ndr_print_ptr(ndr, "architecture", r->architecture);
13413         ndr->depth++;
13414         if (r->architecture) {
13415                 ndr_print_string(ndr, "architecture", r->architecture);
13416         }
13417         ndr->depth--;
13418         ndr_print_ptr(ndr, "file_info", r->file_info);
13419         ndr->depth++;
13420         if (r->file_info) {
13421                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13422                 ndr->depth++;
13423                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13424                         char *idx_1=NULL;
13425                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13426                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13427                                 free(idx_1);
13428                         }
13429                 }
13430                 ndr->depth--;
13431         }
13432         ndr->depth--;
13433         ndr_print_uint32(ndr, "file_count", r->file_count);
13434         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13435         ndr->depth++;
13436         if (r->monitor_name) {
13437                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13438         }
13439         ndr->depth--;
13440         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13441         ndr->depth++;
13442         if (r->default_datatype) {
13443                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13444         }
13445         ndr->depth--;
13446         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13447         ndr->depth++;
13448         if (r->previous_names) {
13449                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13450         }
13451         ndr->depth--;
13452         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13453         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13454         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13455         ndr->depth++;
13456         if (r->manufacturer_name) {
13457                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13458         }
13459         ndr->depth--;
13460         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13461         ndr->depth++;
13462         if (r->manufacturer_url) {
13463                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13464         }
13465         ndr->depth--;
13466         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13467         ndr->depth++;
13468         if (r->hardware_id) {
13469                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13470         }
13471         ndr->depth--;
13472         ndr_print_ptr(ndr, "provider", r->provider);
13473         ndr->depth++;
13474         if (r->provider) {
13475                 ndr_print_string(ndr, "provider", r->provider);
13476         }
13477         ndr->depth--;
13478         ndr->depth--;
13479 }
13480
13481 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13482 {
13483         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13484 }
13485
13486 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13487 {
13488         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13489         if (ndr_flags & NDR_SCALARS) {
13490                 int level = ndr_push_get_switch_value(ndr, r);
13491                 switch (level) {
13492                         case 1: {
13493                                 NDR_CHECK(ndr_push_align(ndr, 4));
13494                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13495                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13496                         break; }
13497
13498                         case 2: {
13499                                 NDR_CHECK(ndr_push_align(ndr, 4));
13500                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13501                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13502                         break; }
13503
13504                         case 3: {
13505                                 NDR_CHECK(ndr_push_align(ndr, 4));
13506                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13507                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13508                         break; }
13509
13510                         case 4: {
13511                                 NDR_CHECK(ndr_push_align(ndr, 4));
13512                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13513                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13514                         break; }
13515
13516                         case 5: {
13517                                 NDR_CHECK(ndr_push_align(ndr, 4));
13518                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13519                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13520                         break; }
13521
13522                         case 6: {
13523                                 NDR_CHECK(ndr_push_align(ndr, 8));
13524                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13525                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13526                         break; }
13527
13528                         case 8: {
13529                                 NDR_CHECK(ndr_push_align(ndr, 8));
13530                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13531                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13532                         break; }
13533
13534                         case 101: {
13535                                 NDR_CHECK(ndr_push_align(ndr, 8));
13536                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13537                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13538                         break; }
13539
13540                         default: {
13541                         break; }
13542
13543                 }
13544         }
13545         if (ndr_flags & NDR_BUFFERS) {
13546                 int level = ndr_push_get_switch_value(ndr, r);
13547                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13548                 switch (level) {
13549                         case 1:
13550                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13551                         break;
13552
13553                         case 2:
13554                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13555                         break;
13556
13557                         case 3:
13558                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13559                         break;
13560
13561                         case 4:
13562                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13563                         break;
13564
13565                         case 5:
13566                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13567                         break;
13568
13569                         case 6:
13570                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13571                         break;
13572
13573                         case 8:
13574                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13575                         break;
13576
13577                         case 101:
13578                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13579                         break;
13580
13581                         default:
13582                         break;
13583
13584                 }
13585         }
13586         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13587         return NDR_ERR_SUCCESS;
13588 }
13589
13590 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13591 {
13592         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13593         int level;
13594         level = ndr_pull_get_switch_value(ndr, r);
13595         if (ndr_flags & NDR_SCALARS) {
13596                 switch (level) {
13597                         case 1: {
13598                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13599                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13600                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13601                         break; }
13602
13603                         case 2: {
13604                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13605                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13606                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13607                         break; }
13608
13609                         case 3: {
13610                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13611                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13612                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13613                         break; }
13614
13615                         case 4: {
13616                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13617                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13618                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13619                         break; }
13620
13621                         case 5: {
13622                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13623                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13624                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13625                         break; }
13626
13627                         case 6: {
13628                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13629                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13630                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13631                         break; }
13632
13633                         case 8: {
13634                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13635                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13636                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13637                         break; }
13638
13639                         case 101: {
13640                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13641                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13642                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13643                         break; }
13644
13645                         default: {
13646                         break; }
13647
13648                 }
13649         }
13650         if (ndr_flags & NDR_BUFFERS) {
13651                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13652                 switch (level) {
13653                         case 1:
13654                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13655                         break;
13656
13657                         case 2:
13658                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13659                         break;
13660
13661                         case 3:
13662                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13663                         break;
13664
13665                         case 4:
13666                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13667                         break;
13668
13669                         case 5:
13670                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13671                         break;
13672
13673                         case 6:
13674                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13675                         break;
13676
13677                         case 8:
13678                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13679                         break;
13680
13681                         case 101:
13682                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13683                         break;
13684
13685                         default:
13686                         break;
13687
13688                 }
13689         }
13690         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13691         return NDR_ERR_SUCCESS;
13692 }
13693
13694 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13695 {
13696         int level;
13697         level = ndr_print_get_switch_value(ndr, r);
13698         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13699         switch (level) {
13700                 case 1:
13701                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13702                 break;
13703
13704                 case 2:
13705                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13706                 break;
13707
13708                 case 3:
13709                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13710                 break;
13711
13712                 case 4:
13713                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13714                 break;
13715
13716                 case 5:
13717                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13718                 break;
13719
13720                 case 6:
13721                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13722                 break;
13723
13724                 case 8:
13725                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13726                 break;
13727
13728                 case 101:
13729                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13730                 break;
13731
13732                 default:
13733                 break;
13734
13735         }
13736 }
13737
13738 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13739 {
13740         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
13741 }
13742
13743 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13744 {
13745         if (ndr_flags & NDR_SCALARS) {
13746                 NDR_CHECK(ndr_push_align(ndr, 4));
13747                 {
13748                         uint32_t _flags_save_string = ndr->flags;
13749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13750                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13751                         ndr->flags = _flags_save_string;
13752                 }
13753         }
13754         if (ndr_flags & NDR_BUFFERS) {
13755         }
13756         return NDR_ERR_SUCCESS;
13757 }
13758
13759 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13760 {
13761         if (ndr_flags & NDR_SCALARS) {
13762                 NDR_CHECK(ndr_pull_align(ndr, 4));
13763                 {
13764                         uint32_t _flags_save_string = ndr->flags;
13765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13766                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13767                         ndr->flags = _flags_save_string;
13768                 }
13769         }
13770         if (ndr_flags & NDR_BUFFERS) {
13771         }
13772         return NDR_ERR_SUCCESS;
13773 }
13774
13775 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13776 {
13777         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13778         ndr->depth++;
13779         ndr_print_string(ndr, "directory_name", r->directory_name);
13780         ndr->depth--;
13781 }
13782
13783 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13784 {
13785         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13786 }
13787
13788 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13789 {
13790         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13791         if (ndr_flags & NDR_SCALARS) {
13792                 int level = ndr_push_get_switch_value(ndr, r);
13793                 switch (level) {
13794                         case 1: {
13795                                 NDR_CHECK(ndr_push_align(ndr, 4));
13796                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13797                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13798                         break; }
13799
13800                         default: {
13801                                 NDR_CHECK(ndr_push_align(ndr, 4));
13802                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13803                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13804                         break; }
13805
13806                 }
13807         }
13808         if (ndr_flags & NDR_BUFFERS) {
13809                 int level = ndr_push_get_switch_value(ndr, r);
13810                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13811                 switch (level) {
13812                         case 1:
13813                         break;
13814
13815                         default:
13816                         break;
13817
13818                 }
13819         }
13820         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13821         return NDR_ERR_SUCCESS;
13822 }
13823
13824 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13825 {
13826         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13827         int level;
13828         level = ndr_pull_get_switch_value(ndr, r);
13829         if (ndr_flags & NDR_SCALARS) {
13830                 switch (level) {
13831                         case 1: {
13832                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13833                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13834                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13835                         break; }
13836
13837                         default: {
13838                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13839                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13840                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13841                         break; }
13842
13843                 }
13844         }
13845         if (ndr_flags & NDR_BUFFERS) {
13846                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13847                 switch (level) {
13848                         case 1:
13849                         break;
13850
13851                         default:
13852                         break;
13853
13854                 }
13855         }
13856         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13857         return NDR_ERR_SUCCESS;
13858 }
13859
13860 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13861 {
13862         int level;
13863         level = ndr_print_get_switch_value(ndr, r);
13864         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13865         switch (level) {
13866                 case 1:
13867                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13868                 break;
13869
13870                 default:
13871                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13872                 break;
13873
13874         }
13875 }
13876
13877 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13878 {
13879         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13880 }
13881
13882 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13883 {
13884         if (ndr_flags & NDR_SCALARS) {
13885                 NDR_CHECK(ndr_push_align(ndr, 4));
13886                 {
13887                         uint32_t _flags_save_string = ndr->flags;
13888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13889                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13890                         ndr->flags = _flags_save_string;
13891                 }
13892         }
13893         if (ndr_flags & NDR_BUFFERS) {
13894                 {
13895                         uint32_t _flags_save_string = ndr->flags;
13896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13897                         if (r->print_processor_name) {
13898                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13899                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13900                         }
13901                         ndr->flags = _flags_save_string;
13902                 }
13903         }
13904         return NDR_ERR_SUCCESS;
13905 }
13906
13907 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13908 {
13909         uint32_t _ptr_print_processor_name;
13910         TALLOC_CTX *_mem_save_print_processor_name_0;
13911         if (ndr_flags & NDR_SCALARS) {
13912                 NDR_CHECK(ndr_pull_align(ndr, 4));
13913                 {
13914                         uint32_t _flags_save_string = ndr->flags;
13915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13916                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13917                         if (_ptr_print_processor_name) {
13918                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13919                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13920                         } else {
13921                                 r->print_processor_name = NULL;
13922                         }
13923                         ndr->flags = _flags_save_string;
13924                 }
13925         }
13926         if (ndr_flags & NDR_BUFFERS) {
13927                 {
13928                         uint32_t _flags_save_string = ndr->flags;
13929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13930                         if (r->print_processor_name) {
13931                                 uint32_t _relative_save_offset;
13932                                 _relative_save_offset = ndr->offset;
13933                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13934                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13935                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13936                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13937                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13938                                 ndr->offset = _relative_save_offset;
13939                         }
13940                         ndr->flags = _flags_save_string;
13941                 }
13942         }
13943         return NDR_ERR_SUCCESS;
13944 }
13945
13946 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13947 {
13948         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13949         ndr->depth++;
13950         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13951         ndr->depth++;
13952         if (r->print_processor_name) {
13953                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13954         }
13955         ndr->depth--;
13956         ndr->depth--;
13957 }
13958
13959 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13960 {
13961         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13962 }
13963
13964 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13965 {
13966         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13967         if (ndr_flags & NDR_SCALARS) {
13968                 int level = ndr_push_get_switch_value(ndr, r);
13969                 switch (level) {
13970                         case 1: {
13971                                 NDR_CHECK(ndr_push_align(ndr, 4));
13972                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13973                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13974                         break; }
13975
13976                         default: {
13977                         break; }
13978
13979                 }
13980         }
13981         if (ndr_flags & NDR_BUFFERS) {
13982                 int level = ndr_push_get_switch_value(ndr, r);
13983                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13984                 switch (level) {
13985                         case 1:
13986                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13987                         break;
13988
13989                         default:
13990                         break;
13991
13992                 }
13993         }
13994         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13995         return NDR_ERR_SUCCESS;
13996 }
13997
13998 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13999 {
14000         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14001         int level;
14002         level = ndr_pull_get_switch_value(ndr, r);
14003         if (ndr_flags & NDR_SCALARS) {
14004                 switch (level) {
14005                         case 1: {
14006                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14007                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14008                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14009                         break; }
14010
14011                         default: {
14012                         break; }
14013
14014                 }
14015         }
14016         if (ndr_flags & NDR_BUFFERS) {
14017                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14018                 switch (level) {
14019                         case 1:
14020                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14021                         break;
14022
14023                         default:
14024                         break;
14025
14026                 }
14027         }
14028         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14029         return NDR_ERR_SUCCESS;
14030 }
14031
14032 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14033 {
14034         int level;
14035         level = ndr_print_get_switch_value(ndr, r);
14036         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14037         switch (level) {
14038                 case 1:
14039                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14040                 break;
14041
14042                 default:
14043                 break;
14044
14045         }
14046 }
14047
14048 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14049 {
14050         if (ndr_flags & NDR_SCALARS) {
14051                 NDR_CHECK(ndr_push_align(ndr, 4));
14052                 {
14053                         uint32_t _flags_save_string = ndr->flags;
14054                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14055                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14056                         ndr->flags = _flags_save_string;
14057                 }
14058         }
14059         if (ndr_flags & NDR_BUFFERS) {
14060         }
14061         return NDR_ERR_SUCCESS;
14062 }
14063
14064 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14065 {
14066         if (ndr_flags & NDR_SCALARS) {
14067                 NDR_CHECK(ndr_pull_align(ndr, 4));
14068                 {
14069                         uint32_t _flags_save_string = ndr->flags;
14070                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14071                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14072                         ndr->flags = _flags_save_string;
14073                 }
14074         }
14075         if (ndr_flags & NDR_BUFFERS) {
14076         }
14077         return NDR_ERR_SUCCESS;
14078 }
14079
14080 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14081 {
14082         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14083         ndr->depth++;
14084         ndr_print_string(ndr, "directory_name", r->directory_name);
14085         ndr->depth--;
14086 }
14087
14088 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14089 {
14090         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14091 }
14092
14093 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14094 {
14095         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14096         if (ndr_flags & NDR_SCALARS) {
14097                 int level = ndr_push_get_switch_value(ndr, r);
14098                 switch (level) {
14099                         case 1: {
14100                                 NDR_CHECK(ndr_push_align(ndr, 4));
14101                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14102                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14103                         break; }
14104
14105                         default: {
14106                                 NDR_CHECK(ndr_push_align(ndr, 4));
14107                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14108                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14109                         break; }
14110
14111                 }
14112         }
14113         if (ndr_flags & NDR_BUFFERS) {
14114                 int level = ndr_push_get_switch_value(ndr, r);
14115                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14116                 switch (level) {
14117                         case 1:
14118                         break;
14119
14120                         default:
14121                         break;
14122
14123                 }
14124         }
14125         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14126         return NDR_ERR_SUCCESS;
14127 }
14128
14129 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14130 {
14131         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14132         int level;
14133         level = ndr_pull_get_switch_value(ndr, r);
14134         if (ndr_flags & NDR_SCALARS) {
14135                 switch (level) {
14136                         case 1: {
14137                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14138                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14139                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14140                         break; }
14141
14142                         default: {
14143                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14144                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14145                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14146                         break; }
14147
14148                 }
14149         }
14150         if (ndr_flags & NDR_BUFFERS) {
14151                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14152                 switch (level) {
14153                         case 1:
14154                         break;
14155
14156                         default:
14157                         break;
14158
14159                 }
14160         }
14161         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14162         return NDR_ERR_SUCCESS;
14163 }
14164
14165 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14166 {
14167         int level;
14168         level = ndr_print_get_switch_value(ndr, r);
14169         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14170         switch (level) {
14171                 case 1:
14172                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14173                 break;
14174
14175                 default:
14176                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14177                 break;
14178
14179         }
14180 }
14181
14182 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14183 {
14184         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14185 }
14186
14187 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14188 {
14189         if (ndr_flags & NDR_SCALARS) {
14190                 NDR_CHECK(ndr_push_align(ndr, 4));
14191                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14192                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14194         }
14195         if (ndr_flags & NDR_BUFFERS) {
14196                 if (r->document_name) {
14197                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14199                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14200                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14201                 }
14202                 if (r->output_file) {
14203                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14204                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14205                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14206                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14207                 }
14208                 if (r->datatype) {
14209                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14210                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14211                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14212                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14213                 }
14214         }
14215         return NDR_ERR_SUCCESS;
14216 }
14217
14218 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14219 {
14220         uint32_t _ptr_document_name;
14221         TALLOC_CTX *_mem_save_document_name_0;
14222         uint32_t _ptr_output_file;
14223         TALLOC_CTX *_mem_save_output_file_0;
14224         uint32_t _ptr_datatype;
14225         TALLOC_CTX *_mem_save_datatype_0;
14226         if (ndr_flags & NDR_SCALARS) {
14227                 NDR_CHECK(ndr_pull_align(ndr, 4));
14228                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14229                 if (_ptr_document_name) {
14230                         NDR_PULL_ALLOC(ndr, r->document_name);
14231                 } else {
14232                         r->document_name = NULL;
14233                 }
14234                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14235                 if (_ptr_output_file) {
14236                         NDR_PULL_ALLOC(ndr, r->output_file);
14237                 } else {
14238                         r->output_file = NULL;
14239                 }
14240                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14241                 if (_ptr_datatype) {
14242                         NDR_PULL_ALLOC(ndr, r->datatype);
14243                 } else {
14244                         r->datatype = NULL;
14245                 }
14246         }
14247         if (ndr_flags & NDR_BUFFERS) {
14248                 if (r->document_name) {
14249                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14250                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14251                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14252                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14253                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14254                                 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));
14255                         }
14256                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14257                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14258                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14259                 }
14260                 if (r->output_file) {
14261                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14262                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14263                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14264                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14265                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14266                                 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));
14267                         }
14268                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14269                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14271                 }
14272                 if (r->datatype) {
14273                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14274                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14275                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14276                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14277                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14278                                 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));
14279                         }
14280                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14281                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14282                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14283                 }
14284         }
14285         return NDR_ERR_SUCCESS;
14286 }
14287
14288 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14289 {
14290         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14291         ndr->depth++;
14292         ndr_print_ptr(ndr, "document_name", r->document_name);
14293         ndr->depth++;
14294         if (r->document_name) {
14295                 ndr_print_string(ndr, "document_name", r->document_name);
14296         }
14297         ndr->depth--;
14298         ndr_print_ptr(ndr, "output_file", r->output_file);
14299         ndr->depth++;
14300         if (r->output_file) {
14301                 ndr_print_string(ndr, "output_file", r->output_file);
14302         }
14303         ndr->depth--;
14304         ndr_print_ptr(ndr, "datatype", r->datatype);
14305         ndr->depth++;
14306         if (r->datatype) {
14307                 ndr_print_string(ndr, "datatype", r->datatype);
14308         }
14309         ndr->depth--;
14310         ndr->depth--;
14311 }
14312
14313 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14314 {
14315         if (ndr_flags & NDR_SCALARS) {
14316                 int level = ndr_push_get_switch_value(ndr, r);
14317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14318                 switch (level) {
14319                         case 1: {
14320                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14321                         break; }
14322
14323                         case 2: {
14324                         break; }
14325
14326                         case 3: {
14327                         break; }
14328
14329                         default: {
14330                         break; }
14331
14332                 }
14333         }
14334         if (ndr_flags & NDR_BUFFERS) {
14335                 int level = ndr_push_get_switch_value(ndr, r);
14336                 switch (level) {
14337                         case 1:
14338                                 if (r->info1) {
14339                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14340                                 }
14341                         break;
14342
14343                         case 2:
14344                         break;
14345
14346                         case 3:
14347                         break;
14348
14349                         default:
14350                         break;
14351
14352                 }
14353         }
14354         return NDR_ERR_SUCCESS;
14355 }
14356
14357 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14358 {
14359         int level;
14360         uint32_t _level;
14361         TALLOC_CTX *_mem_save_info1_0;
14362         level = ndr_pull_get_switch_value(ndr, r);
14363         if (ndr_flags & NDR_SCALARS) {
14364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14365                 if (_level != level) {
14366                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14367                 }
14368                 switch (level) {
14369                         case 1: {
14370                                 uint32_t _ptr_info1;
14371                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14372                                 if (_ptr_info1) {
14373                                         NDR_PULL_ALLOC(ndr, r->info1);
14374                                 } else {
14375                                         r->info1 = NULL;
14376                                 }
14377                         break; }
14378
14379                         case 2: {
14380                         break; }
14381
14382                         case 3: {
14383                         break; }
14384
14385                         default: {
14386                         break; }
14387
14388                 }
14389         }
14390         if (ndr_flags & NDR_BUFFERS) {
14391                 switch (level) {
14392                         case 1:
14393                                 if (r->info1) {
14394                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14395                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14396                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14397                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14398                                 }
14399                         break;
14400
14401                         case 2:
14402                         break;
14403
14404                         case 3:
14405                         break;
14406
14407                         default:
14408                         break;
14409
14410                 }
14411         }
14412         return NDR_ERR_SUCCESS;
14413 }
14414
14415 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14416 {
14417         int level;
14418         level = ndr_print_get_switch_value(ndr, r);
14419         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14420         switch (level) {
14421                 case 1:
14422                         ndr_print_ptr(ndr, "info1", r->info1);
14423                         ndr->depth++;
14424                         if (r->info1) {
14425                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14426                         }
14427                         ndr->depth--;
14428                 break;
14429
14430                 case 2:
14431                 break;
14432
14433                 case 3:
14434                 break;
14435
14436                 default:
14437                 break;
14438
14439         }
14440 }
14441
14442 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14443 {
14444         if (ndr_flags & NDR_SCALARS) {
14445                 NDR_CHECK(ndr_push_align(ndr, 4));
14446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14451                 {
14452                         uint32_t _flags_save_string = ndr->flags;
14453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14454                         {
14455                                 struct ndr_push *_ndr_extra_string;
14456                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14457                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14458                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14459                         }
14460                         ndr->flags = _flags_save_string;
14461                 }
14462         }
14463         if (ndr_flags & NDR_BUFFERS) {
14464         }
14465         return NDR_ERR_SUCCESS;
14466 }
14467
14468 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14469 {
14470         if (ndr_flags & NDR_SCALARS) {
14471                 NDR_CHECK(ndr_pull_align(ndr, 4));
14472                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14475                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14477                 {
14478                         uint32_t _flags_save_string = ndr->flags;
14479                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14480                         {
14481                                 struct ndr_pull *_ndr_extra_string;
14482                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14483                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14484                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14485                         }
14486                         ndr->flags = _flags_save_string;
14487                 }
14488         }
14489         if (ndr_flags & NDR_BUFFERS) {
14490         }
14491         return NDR_ERR_SUCCESS;
14492 }
14493
14494 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14495 {
14496         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14497         ndr->depth++;
14498         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);
14499         ndr_print_uint32(ndr, "major", r->major);
14500         ndr_print_uint32(ndr, "minor", r->minor);
14501         ndr_print_uint32(ndr, "build", r->build);
14502         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14503         ndr_print_string(ndr, "extra_string", r->extra_string);
14504         ndr->depth--;
14505 }
14506
14507 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14508 {
14509         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14510 }
14511
14512 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14513 {
14514         if (ndr_flags & NDR_SCALARS) {
14515                 NDR_CHECK(ndr_push_align(ndr, 4));
14516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14521                 {
14522                         uint32_t _flags_save_string = ndr->flags;
14523                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14524                         {
14525                                 struct ndr_push *_ndr_extra_string;
14526                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14527                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14528                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14529                         }
14530                         ndr->flags = _flags_save_string;
14531                 }
14532                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14534         }
14535         if (ndr_flags & NDR_BUFFERS) {
14536         }
14537         return NDR_ERR_SUCCESS;
14538 }
14539
14540 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14541 {
14542         if (ndr_flags & NDR_SCALARS) {
14543                 NDR_CHECK(ndr_pull_align(ndr, 4));
14544                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14546                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14547                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14549                 {
14550                         uint32_t _flags_save_string = ndr->flags;
14551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14552                         {
14553                                 struct ndr_pull *_ndr_extra_string;
14554                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14555                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14556                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14557                         }
14558                         ndr->flags = _flags_save_string;
14559                 }
14560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14562         }
14563         if (ndr_flags & NDR_BUFFERS) {
14564         }
14565         return NDR_ERR_SUCCESS;
14566 }
14567
14568 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14569 {
14570         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14571         ndr->depth++;
14572         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);
14573         ndr_print_uint32(ndr, "major", r->major);
14574         ndr_print_uint32(ndr, "minor", r->minor);
14575         ndr_print_uint32(ndr, "build", r->build);
14576         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14577         ndr_print_string(ndr, "extra_string", r->extra_string);
14578         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14579         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14580         ndr->depth--;
14581 }
14582
14583 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14584 {
14585         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14586 }
14587
14588 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14589 {
14590         if (ndr_flags & NDR_SCALARS) {
14591                 int level = ndr_push_get_switch_value(ndr, r);
14592                 switch (level) {
14593                         case REG_NONE: {
14594                         break; }
14595
14596                         case REG_SZ: {
14597                                 {
14598                                         uint32_t _flags_save_string = ndr->flags;
14599                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14600                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14601                                         ndr->flags = _flags_save_string;
14602                                 }
14603                         break; }
14604
14605                         case REG_BINARY: {
14606                                 {
14607                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14608                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14609                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14610                                         ndr->flags = _flags_save_DATA_BLOB;
14611                                 }
14612                         break; }
14613
14614                         case REG_DWORD: {
14615                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14616                         break; }
14617
14618                         case REG_MULTI_SZ: {
14619                                 {
14620                                         uint32_t _flags_save_string_array = ndr->flags;
14621                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14622                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14623                                         ndr->flags = _flags_save_string_array;
14624                                 }
14625                         break; }
14626
14627                         default: {
14628                                 {
14629                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14630                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14631                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14632                                         ndr->flags = _flags_save_DATA_BLOB;
14633                                 }
14634                         break; }
14635
14636                 }
14637         }
14638         if (ndr_flags & NDR_BUFFERS) {
14639                 int level = ndr_push_get_switch_value(ndr, r);
14640                 switch (level) {
14641                         case REG_NONE:
14642                         break;
14643
14644                         case REG_SZ:
14645                         break;
14646
14647                         case REG_BINARY:
14648                         break;
14649
14650                         case REG_DWORD:
14651                         break;
14652
14653                         case REG_MULTI_SZ:
14654                         break;
14655
14656                         default:
14657                         break;
14658
14659                 }
14660         }
14661         return NDR_ERR_SUCCESS;
14662 }
14663
14664 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14665 {
14666         int level;
14667         level = ndr_pull_get_switch_value(ndr, r);
14668         if (ndr_flags & NDR_SCALARS) {
14669                 switch (level) {
14670                         case REG_NONE: {
14671                         break; }
14672
14673                         case REG_SZ: {
14674                                 {
14675                                         uint32_t _flags_save_string = ndr->flags;
14676                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14677                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14678                                         ndr->flags = _flags_save_string;
14679                                 }
14680                         break; }
14681
14682                         case REG_BINARY: {
14683                                 {
14684                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14685                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14686                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14687                                         ndr->flags = _flags_save_DATA_BLOB;
14688                                 }
14689                         break; }
14690
14691                         case REG_DWORD: {
14692                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14693                         break; }
14694
14695                         case REG_MULTI_SZ: {
14696                                 {
14697                                         uint32_t _flags_save_string_array = ndr->flags;
14698                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14699                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14700                                         ndr->flags = _flags_save_string_array;
14701                                 }
14702                         break; }
14703
14704                         default: {
14705                                 {
14706                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14707                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14708                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14709                                         ndr->flags = _flags_save_DATA_BLOB;
14710                                 }
14711                         break; }
14712
14713                 }
14714         }
14715         if (ndr_flags & NDR_BUFFERS) {
14716                 switch (level) {
14717                         case REG_NONE:
14718                         break;
14719
14720                         case REG_SZ:
14721                         break;
14722
14723                         case REG_BINARY:
14724                         break;
14725
14726                         case REG_DWORD:
14727                         break;
14728
14729                         case REG_MULTI_SZ:
14730                         break;
14731
14732                         default:
14733                         break;
14734
14735                 }
14736         }
14737         return NDR_ERR_SUCCESS;
14738 }
14739
14740 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14741 {
14742         int level;
14743         level = ndr_print_get_switch_value(ndr, r);
14744         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14745         switch (level) {
14746                 case REG_NONE:
14747                 break;
14748
14749                 case REG_SZ:
14750                         ndr_print_string(ndr, "string", r->string);
14751                 break;
14752
14753                 case REG_BINARY:
14754                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14755                 break;
14756
14757                 case REG_DWORD:
14758                         ndr_print_uint32(ndr, "value", r->value);
14759                 break;
14760
14761                 case REG_MULTI_SZ:
14762                         ndr_print_string_array(ndr, "string_array", r->string_array);
14763                 break;
14764
14765                 default:
14766                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14767                 break;
14768
14769         }
14770 }
14771
14772 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14773 {
14774         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14775 }
14776
14777 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14778 {
14779         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14780         return NDR_ERR_SUCCESS;
14781 }
14782
14783 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14784 {
14785         uint32_t v;
14786         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14787         *r = v;
14788         return NDR_ERR_SUCCESS;
14789 }
14790
14791 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14792 {
14793         const char *val = NULL;
14794
14795         switch (r) {
14796                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14797                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14798                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14799         }
14800         ndr_print_enum(ndr, name, "ENUM", val, r);
14801 }
14802
14803 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14804 {
14805         if (ndr_flags & NDR_SCALARS) {
14806                 NDR_CHECK(ndr_push_align(ndr, 4));
14807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14809         }
14810         if (ndr_flags & NDR_BUFFERS) {
14811         }
14812         return NDR_ERR_SUCCESS;
14813 }
14814
14815 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14816 {
14817         if (ndr_flags & NDR_SCALARS) {
14818                 NDR_CHECK(ndr_pull_align(ndr, 4));
14819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14821         }
14822         if (ndr_flags & NDR_BUFFERS) {
14823         }
14824         return NDR_ERR_SUCCESS;
14825 }
14826
14827 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14828 {
14829         ndr_print_struct(ndr, name, "spoolss_FormSize");
14830         ndr->depth++;
14831         ndr_print_uint32(ndr, "width", r->width);
14832         ndr_print_uint32(ndr, "height", r->height);
14833         ndr->depth--;
14834 }
14835
14836 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14837 {
14838         if (ndr_flags & NDR_SCALARS) {
14839                 NDR_CHECK(ndr_push_align(ndr, 4));
14840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14843                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14844         }
14845         if (ndr_flags & NDR_BUFFERS) {
14846         }
14847         return NDR_ERR_SUCCESS;
14848 }
14849
14850 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14851 {
14852         if (ndr_flags & NDR_SCALARS) {
14853                 NDR_CHECK(ndr_pull_align(ndr, 4));
14854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14858         }
14859         if (ndr_flags & NDR_BUFFERS) {
14860         }
14861         return NDR_ERR_SUCCESS;
14862 }
14863
14864 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14865 {
14866         ndr_print_struct(ndr, name, "spoolss_FormArea");
14867         ndr->depth++;
14868         ndr_print_uint32(ndr, "left", r->left);
14869         ndr_print_uint32(ndr, "top", r->top);
14870         ndr_print_uint32(ndr, "right", r->right);
14871         ndr_print_uint32(ndr, "bottom", r->bottom);
14872         ndr->depth--;
14873 }
14874
14875 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14876 {
14877         if (ndr_flags & NDR_SCALARS) {
14878                 NDR_CHECK(ndr_push_align(ndr, 4));
14879                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14880                 {
14881                         uint32_t _flags_save_string = ndr->flags;
14882                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14883                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14884                         ndr->flags = _flags_save_string;
14885                 }
14886                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14887                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14888         }
14889         if (ndr_flags & NDR_BUFFERS) {
14890                 {
14891                         uint32_t _flags_save_string = ndr->flags;
14892                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14893                         if (r->form_name) {
14894                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14895                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14896                         }
14897                         ndr->flags = _flags_save_string;
14898                 }
14899         }
14900         return NDR_ERR_SUCCESS;
14901 }
14902
14903 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14904 {
14905         uint32_t _ptr_form_name;
14906         TALLOC_CTX *_mem_save_form_name_0;
14907         if (ndr_flags & NDR_SCALARS) {
14908                 NDR_CHECK(ndr_pull_align(ndr, 4));
14909                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14910                 {
14911                         uint32_t _flags_save_string = ndr->flags;
14912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14913                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14914                         if (_ptr_form_name) {
14915                                 NDR_PULL_ALLOC(ndr, r->form_name);
14916                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14917                         } else {
14918                                 r->form_name = NULL;
14919                         }
14920                         ndr->flags = _flags_save_string;
14921                 }
14922                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14923                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14924         }
14925         if (ndr_flags & NDR_BUFFERS) {
14926                 {
14927                         uint32_t _flags_save_string = ndr->flags;
14928                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14929                         if (r->form_name) {
14930                                 uint32_t _relative_save_offset;
14931                                 _relative_save_offset = ndr->offset;
14932                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14933                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14934                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14935                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14936                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14937                                 ndr->offset = _relative_save_offset;
14938                         }
14939                         ndr->flags = _flags_save_string;
14940                 }
14941         }
14942         return NDR_ERR_SUCCESS;
14943 }
14944
14945 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14946 {
14947         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14948         ndr->depth++;
14949         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14950         ndr_print_ptr(ndr, "form_name", r->form_name);
14951         ndr->depth++;
14952         if (r->form_name) {
14953                 ndr_print_string(ndr, "form_name", r->form_name);
14954         }
14955         ndr->depth--;
14956         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14957         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14958         ndr->depth--;
14959 }
14960
14961 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14962 {
14963         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14964 }
14965
14966 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14967 {
14968         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14969         return NDR_ERR_SUCCESS;
14970 }
14971
14972 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14973 {
14974         uint32_t v;
14975         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14976         *r = v;
14977         return NDR_ERR_SUCCESS;
14978 }
14979
14980 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14981 {
14982         ndr_print_uint32(ndr, name, r);
14983         ndr->depth++;
14984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14985         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14986         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14987         ndr->depth--;
14988 }
14989
14990 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14991 {
14992         if (ndr_flags & NDR_SCALARS) {
14993                 NDR_CHECK(ndr_push_align(ndr, 4));
14994                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14995                 {
14996                         uint32_t _flags_save_string = ndr->flags;
14997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14998                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14999                         ndr->flags = _flags_save_string;
15000                 }
15001                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15002                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15003                 {
15004                         uint32_t _flags_save_string = ndr->flags;
15005                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15006                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
15007                         ndr->flags = _flags_save_string;
15008                 }
15009                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15010                 {
15011                         uint32_t _flags_save_string = ndr->flags;
15012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15014                         ndr->flags = _flags_save_string;
15015                 }
15016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15017                 {
15018                         uint32_t _flags_save_string = ndr->flags;
15019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15020                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15021                         ndr->flags = _flags_save_string;
15022                 }
15023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15024         }
15025         if (ndr_flags & NDR_BUFFERS) {
15026                 {
15027                         uint32_t _flags_save_string = ndr->flags;
15028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15029                         if (r->form_name) {
15030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
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_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15038                         if (r->keyword) {
15039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
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->mui_dll) {
15048                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15049                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15050                         }
15051                         ndr->flags = _flags_save_string;
15052                 }
15053                 {
15054                         uint32_t _flags_save_string = ndr->flags;
15055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15056                         if (r->display_name) {
15057                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15058                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15059                         }
15060                         ndr->flags = _flags_save_string;
15061                 }
15062         }
15063         return NDR_ERR_SUCCESS;
15064 }
15065
15066 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15067 {
15068         uint32_t _ptr_form_name;
15069         TALLOC_CTX *_mem_save_form_name_0;
15070         uint32_t _ptr_keyword;
15071         TALLOC_CTX *_mem_save_keyword_0;
15072         uint32_t _ptr_mui_dll;
15073         TALLOC_CTX *_mem_save_mui_dll_0;
15074         uint32_t _ptr_display_name;
15075         TALLOC_CTX *_mem_save_display_name_0;
15076         if (ndr_flags & NDR_SCALARS) {
15077                 NDR_CHECK(ndr_pull_align(ndr, 4));
15078                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15079                 {
15080                         uint32_t _flags_save_string = ndr->flags;
15081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15082                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15083                         if (_ptr_form_name) {
15084                                 NDR_PULL_ALLOC(ndr, r->form_name);
15085                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15086                         } else {
15087                                 r->form_name = NULL;
15088                         }
15089                         ndr->flags = _flags_save_string;
15090                 }
15091                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15092                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15093                 {
15094                         uint32_t _flags_save_string = ndr->flags;
15095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15096                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15097                         if (_ptr_keyword) {
15098                                 NDR_PULL_ALLOC(ndr, r->keyword);
15099                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15100                         } else {
15101                                 r->keyword = NULL;
15102                         }
15103                         ndr->flags = _flags_save_string;
15104                 }
15105                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15106                 {
15107                         uint32_t _flags_save_string = ndr->flags;
15108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15109                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15110                         if (_ptr_mui_dll) {
15111                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15112                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15113                         } else {
15114                                 r->mui_dll = NULL;
15115                         }
15116                         ndr->flags = _flags_save_string;
15117                 }
15118                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15119                 {
15120                         uint32_t _flags_save_string = ndr->flags;
15121                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15122                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15123                         if (_ptr_display_name) {
15124                                 NDR_PULL_ALLOC(ndr, r->display_name);
15125                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15126                         } else {
15127                                 r->display_name = NULL;
15128                         }
15129                         ndr->flags = _flags_save_string;
15130                 }
15131                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15132         }
15133         if (ndr_flags & NDR_BUFFERS) {
15134                 {
15135                         uint32_t _flags_save_string = ndr->flags;
15136                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15137                         if (r->form_name) {
15138                                 uint32_t _relative_save_offset;
15139                                 _relative_save_offset = ndr->offset;
15140                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15141                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15142                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15143                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15144                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15145                                 ndr->offset = _relative_save_offset;
15146                         }
15147                         ndr->flags = _flags_save_string;
15148                 }
15149                 {
15150                         uint32_t _flags_save_string = ndr->flags;
15151                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15152                         if (r->keyword) {
15153                                 uint32_t _relative_save_offset;
15154                                 _relative_save_offset = ndr->offset;
15155                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15156                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15157                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15158                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15159                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15160                                 ndr->offset = _relative_save_offset;
15161                         }
15162                         ndr->flags = _flags_save_string;
15163                 }
15164                 {
15165                         uint32_t _flags_save_string = ndr->flags;
15166                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15167                         if (r->mui_dll) {
15168                                 uint32_t _relative_save_offset;
15169                                 _relative_save_offset = ndr->offset;
15170                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15171                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15172                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15173                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15174                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15175                                 ndr->offset = _relative_save_offset;
15176                         }
15177                         ndr->flags = _flags_save_string;
15178                 }
15179                 {
15180                         uint32_t _flags_save_string = ndr->flags;
15181                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15182                         if (r->display_name) {
15183                                 uint32_t _relative_save_offset;
15184                                 _relative_save_offset = ndr->offset;
15185                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15186                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15187                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15188                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15189                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15190                                 ndr->offset = _relative_save_offset;
15191                         }
15192                         ndr->flags = _flags_save_string;
15193                 }
15194         }
15195         return NDR_ERR_SUCCESS;
15196 }
15197
15198 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15199 {
15200         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15201         ndr->depth++;
15202         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15203         ndr_print_ptr(ndr, "form_name", r->form_name);
15204         ndr->depth++;
15205         if (r->form_name) {
15206                 ndr_print_string(ndr, "form_name", r->form_name);
15207         }
15208         ndr->depth--;
15209         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15210         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15211         ndr_print_ptr(ndr, "keyword", r->keyword);
15212         ndr->depth++;
15213         if (r->keyword) {
15214                 ndr_print_string(ndr, "keyword", r->keyword);
15215         }
15216         ndr->depth--;
15217         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15218         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15219         ndr->depth++;
15220         if (r->mui_dll) {
15221                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15222         }
15223         ndr->depth--;
15224         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15225         ndr_print_ptr(ndr, "display_name", r->display_name);
15226         ndr->depth++;
15227         if (r->display_name) {
15228                 ndr_print_string(ndr, "display_name", r->display_name);
15229         }
15230         ndr->depth--;
15231         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15232         ndr->depth--;
15233 }
15234
15235 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15236 {
15237         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15238 }
15239
15240 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15241 {
15242         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15243         if (ndr_flags & NDR_SCALARS) {
15244                 int level = ndr_push_get_switch_value(ndr, r);
15245                 switch (level) {
15246                         case 1: {
15247                                 NDR_CHECK(ndr_push_align(ndr, 4));
15248                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15249                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15250                         break; }
15251
15252                         case 2: {
15253                                 NDR_CHECK(ndr_push_align(ndr, 4));
15254                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15255                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15256                         break; }
15257
15258                         default: {
15259                         break; }
15260
15261                 }
15262         }
15263         if (ndr_flags & NDR_BUFFERS) {
15264                 int level = ndr_push_get_switch_value(ndr, r);
15265                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15266                 switch (level) {
15267                         case 1:
15268                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15269                         break;
15270
15271                         case 2:
15272                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15273                         break;
15274
15275                         default:
15276                         break;
15277
15278                 }
15279         }
15280         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15281         return NDR_ERR_SUCCESS;
15282 }
15283
15284 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15285 {
15286         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15287         int level;
15288         level = ndr_pull_get_switch_value(ndr, r);
15289         if (ndr_flags & NDR_SCALARS) {
15290                 switch (level) {
15291                         case 1: {
15292                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15293                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15294                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15295                         break; }
15296
15297                         case 2: {
15298                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15299                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15300                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15301                         break; }
15302
15303                         default: {
15304                         break; }
15305
15306                 }
15307         }
15308         if (ndr_flags & NDR_BUFFERS) {
15309                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15310                 switch (level) {
15311                         case 1:
15312                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15313                         break;
15314
15315                         case 2:
15316                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15317                         break;
15318
15319                         default:
15320                         break;
15321
15322                 }
15323         }
15324         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15325         return NDR_ERR_SUCCESS;
15326 }
15327
15328 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15329 {
15330         int level;
15331         level = ndr_print_get_switch_value(ndr, r);
15332         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15333         switch (level) {
15334                 case 1:
15335                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15336                 break;
15337
15338                 case 2:
15339                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15340                 break;
15341
15342                 default:
15343                 break;
15344
15345         }
15346 }
15347
15348 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15349 {
15350         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15351 }
15352
15353 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15354 {
15355         if (ndr_flags & NDR_SCALARS) {
15356                 NDR_CHECK(ndr_push_align(ndr, 4));
15357                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15358                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15359                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15360                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15361         }
15362         if (ndr_flags & NDR_BUFFERS) {
15363                 if (r->form_name) {
15364                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15365                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15366                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15367                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15368                 }
15369         }
15370         return NDR_ERR_SUCCESS;
15371 }
15372
15373 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15374 {
15375         uint32_t _ptr_form_name;
15376         TALLOC_CTX *_mem_save_form_name_0;
15377         if (ndr_flags & NDR_SCALARS) {
15378                 NDR_CHECK(ndr_pull_align(ndr, 4));
15379                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15380                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15381                 if (_ptr_form_name) {
15382                         NDR_PULL_ALLOC(ndr, r->form_name);
15383                 } else {
15384                         r->form_name = NULL;
15385                 }
15386                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15387                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15388         }
15389         if (ndr_flags & NDR_BUFFERS) {
15390                 if (r->form_name) {
15391                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15392                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15393                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15394                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15395                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15396                                 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));
15397                         }
15398                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15399                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15401                 }
15402         }
15403         return NDR_ERR_SUCCESS;
15404 }
15405
15406 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15407 {
15408         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15409         ndr->depth++;
15410         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15411         ndr_print_ptr(ndr, "form_name", r->form_name);
15412         ndr->depth++;
15413         if (r->form_name) {
15414                 ndr_print_string(ndr, "form_name", r->form_name);
15415         }
15416         ndr->depth--;
15417         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15418         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15419         ndr->depth--;
15420 }
15421
15422 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15423 {
15424         if (ndr_flags & NDR_SCALARS) {
15425                 NDR_CHECK(ndr_push_align(ndr, 4));
15426                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15427                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15428                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15429                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15431                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15432                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15434                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15436         }
15437         if (ndr_flags & NDR_BUFFERS) {
15438                 if (r->form_name) {
15439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15442                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15443                 }
15444                 if (r->keyword) {
15445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15448                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15449                 }
15450                 if (r->mui_dll) {
15451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15454                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15455                 }
15456                 if (r->display_name) {
15457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15460                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15461                 }
15462         }
15463         return NDR_ERR_SUCCESS;
15464 }
15465
15466 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15467 {
15468         uint32_t _ptr_form_name;
15469         TALLOC_CTX *_mem_save_form_name_0;
15470         uint32_t _ptr_keyword;
15471         TALLOC_CTX *_mem_save_keyword_0;
15472         uint32_t _ptr_mui_dll;
15473         TALLOC_CTX *_mem_save_mui_dll_0;
15474         uint32_t _ptr_display_name;
15475         TALLOC_CTX *_mem_save_display_name_0;
15476         if (ndr_flags & NDR_SCALARS) {
15477                 NDR_CHECK(ndr_pull_align(ndr, 4));
15478                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15479                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15480                 if (_ptr_form_name) {
15481                         NDR_PULL_ALLOC(ndr, r->form_name);
15482                 } else {
15483                         r->form_name = NULL;
15484                 }
15485                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15486                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15487                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15488                 if (_ptr_keyword) {
15489                         NDR_PULL_ALLOC(ndr, r->keyword);
15490                 } else {
15491                         r->keyword = NULL;
15492                 }
15493                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15494                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15495                 if (_ptr_mui_dll) {
15496                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15497                 } else {
15498                         r->mui_dll = NULL;
15499                 }
15500                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15502                 if (_ptr_display_name) {
15503                         NDR_PULL_ALLOC(ndr, r->display_name);
15504                 } else {
15505                         r->display_name = NULL;
15506                 }
15507                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15508         }
15509         if (ndr_flags & NDR_BUFFERS) {
15510                 if (r->form_name) {
15511                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15512                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15513                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15514                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15515                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15516                                 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));
15517                         }
15518                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15519                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15520                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15521                 }
15522                 if (r->keyword) {
15523                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15524                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15525                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15526                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15527                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15528                                 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));
15529                         }
15530                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15531                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15532                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15533                 }
15534                 if (r->mui_dll) {
15535                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15536                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15537                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15538                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15539                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15540                                 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));
15541                         }
15542                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15543                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15544                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15545                 }
15546                 if (r->display_name) {
15547                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15548                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15549                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15550                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15551                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15552                                 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));
15553                         }
15554                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15555                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15556                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15557                 }
15558         }
15559         return NDR_ERR_SUCCESS;
15560 }
15561
15562 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15563 {
15564         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15565         ndr->depth++;
15566         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15567         ndr_print_ptr(ndr, "form_name", r->form_name);
15568         ndr->depth++;
15569         if (r->form_name) {
15570                 ndr_print_string(ndr, "form_name", r->form_name);
15571         }
15572         ndr->depth--;
15573         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15574         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15575         ndr_print_ptr(ndr, "keyword", r->keyword);
15576         ndr->depth++;
15577         if (r->keyword) {
15578                 ndr_print_string(ndr, "keyword", r->keyword);
15579         }
15580         ndr->depth--;
15581         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15582         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15583         ndr->depth++;
15584         if (r->mui_dll) {
15585                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15586         }
15587         ndr->depth--;
15588         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15589         ndr_print_ptr(ndr, "display_name", r->display_name);
15590         ndr->depth++;
15591         if (r->display_name) {
15592                 ndr_print_string(ndr, "display_name", r->display_name);
15593         }
15594         ndr->depth--;
15595         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15596         ndr->depth--;
15597 }
15598
15599 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15600 {
15601         if (ndr_flags & NDR_SCALARS) {
15602                 int level = ndr_push_get_switch_value(ndr, r);
15603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15604                 switch (level) {
15605                         case 1: {
15606                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15607                         break; }
15608
15609                         case 2: {
15610                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15611                         break; }
15612
15613                         default:
15614                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15615                 }
15616         }
15617         if (ndr_flags & NDR_BUFFERS) {
15618                 int level = ndr_push_get_switch_value(ndr, r);
15619                 switch (level) {
15620                         case 1:
15621                                 if (r->info1) {
15622                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15623                                 }
15624                         break;
15625
15626                         case 2:
15627                                 if (r->info2) {
15628                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15629                                 }
15630                         break;
15631
15632                         default:
15633                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15634                 }
15635         }
15636         return NDR_ERR_SUCCESS;
15637 }
15638
15639 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15640 {
15641         int level;
15642         uint32_t _level;
15643         TALLOC_CTX *_mem_save_info1_0;
15644         TALLOC_CTX *_mem_save_info2_0;
15645         level = ndr_pull_get_switch_value(ndr, r);
15646         if (ndr_flags & NDR_SCALARS) {
15647                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15648                 if (_level != level) {
15649                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15650                 }
15651                 switch (level) {
15652                         case 1: {
15653                                 uint32_t _ptr_info1;
15654                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15655                                 if (_ptr_info1) {
15656                                         NDR_PULL_ALLOC(ndr, r->info1);
15657                                 } else {
15658                                         r->info1 = NULL;
15659                                 }
15660                         break; }
15661
15662                         case 2: {
15663                                 uint32_t _ptr_info2;
15664                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15665                                 if (_ptr_info2) {
15666                                         NDR_PULL_ALLOC(ndr, r->info2);
15667                                 } else {
15668                                         r->info2 = NULL;
15669                                 }
15670                         break; }
15671
15672                         default:
15673                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15674                 }
15675         }
15676         if (ndr_flags & NDR_BUFFERS) {
15677                 switch (level) {
15678                         case 1:
15679                                 if (r->info1) {
15680                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15681                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15682                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15683                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15684                                 }
15685                         break;
15686
15687                         case 2:
15688                                 if (r->info2) {
15689                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15690                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15691                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15692                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15693                                 }
15694                         break;
15695
15696                         default:
15697                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15698                 }
15699         }
15700         return NDR_ERR_SUCCESS;
15701 }
15702
15703 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15704 {
15705         int level;
15706         level = ndr_print_get_switch_value(ndr, r);
15707         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15708         switch (level) {
15709                 case 1:
15710                         ndr_print_ptr(ndr, "info1", r->info1);
15711                         ndr->depth++;
15712                         if (r->info1) {
15713                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15714                         }
15715                         ndr->depth--;
15716                 break;
15717
15718                 case 2:
15719                         ndr_print_ptr(ndr, "info2", r->info2);
15720                         ndr->depth++;
15721                         if (r->info2) {
15722                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15723                         }
15724                         ndr->depth--;
15725                 break;
15726
15727                 default:
15728                         ndr_print_bad_level(ndr, name, level);
15729         }
15730 }
15731
15732 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15733 {
15734         if (ndr_flags & NDR_SCALARS) {
15735                 NDR_CHECK(ndr_push_align(ndr, 4));
15736                 {
15737                         uint32_t _flags_save_string = ndr->flags;
15738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15739                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15740                         ndr->flags = _flags_save_string;
15741                 }
15742         }
15743         if (ndr_flags & NDR_BUFFERS) {
15744                 {
15745                         uint32_t _flags_save_string = ndr->flags;
15746                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15747                         if (r->port_name) {
15748                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15749                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15750                         }
15751                         ndr->flags = _flags_save_string;
15752                 }
15753         }
15754         return NDR_ERR_SUCCESS;
15755 }
15756
15757 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15758 {
15759         uint32_t _ptr_port_name;
15760         TALLOC_CTX *_mem_save_port_name_0;
15761         if (ndr_flags & NDR_SCALARS) {
15762                 NDR_CHECK(ndr_pull_align(ndr, 4));
15763                 {
15764                         uint32_t _flags_save_string = ndr->flags;
15765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15766                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15767                         if (_ptr_port_name) {
15768                                 NDR_PULL_ALLOC(ndr, r->port_name);
15769                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15770                         } else {
15771                                 r->port_name = NULL;
15772                         }
15773                         ndr->flags = _flags_save_string;
15774                 }
15775         }
15776         if (ndr_flags & NDR_BUFFERS) {
15777                 {
15778                         uint32_t _flags_save_string = ndr->flags;
15779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15780                         if (r->port_name) {
15781                                 uint32_t _relative_save_offset;
15782                                 _relative_save_offset = ndr->offset;
15783                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15784                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15785                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15786                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15787                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15788                                 ndr->offset = _relative_save_offset;
15789                         }
15790                         ndr->flags = _flags_save_string;
15791                 }
15792         }
15793         return NDR_ERR_SUCCESS;
15794 }
15795
15796 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15797 {
15798         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15799         ndr->depth++;
15800         ndr_print_ptr(ndr, "port_name", r->port_name);
15801         ndr->depth++;
15802         if (r->port_name) {
15803                 ndr_print_string(ndr, "port_name", r->port_name);
15804         }
15805         ndr->depth--;
15806         ndr->depth--;
15807 }
15808
15809 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15810 {
15811         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15812 }
15813
15814 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15815 {
15816         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15817         return NDR_ERR_SUCCESS;
15818 }
15819
15820 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15821 {
15822         uint32_t v;
15823         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15824         *r = v;
15825         return NDR_ERR_SUCCESS;
15826 }
15827
15828 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15829 {
15830         ndr_print_uint32(ndr, name, r);
15831         ndr->depth++;
15832         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15833         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15834         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15835         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15836         ndr->depth--;
15837 }
15838
15839 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15840 {
15841         if (ndr_flags & NDR_SCALARS) {
15842                 NDR_CHECK(ndr_push_align(ndr, 4));
15843                 {
15844                         uint32_t _flags_save_string = ndr->flags;
15845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15846                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15847                         ndr->flags = _flags_save_string;
15848                 }
15849                 {
15850                         uint32_t _flags_save_string = ndr->flags;
15851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15852                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15853                         ndr->flags = _flags_save_string;
15854                 }
15855                 {
15856                         uint32_t _flags_save_string = ndr->flags;
15857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15858                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15859                         ndr->flags = _flags_save_string;
15860                 }
15861                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15863         }
15864         if (ndr_flags & NDR_BUFFERS) {
15865                 {
15866                         uint32_t _flags_save_string = ndr->flags;
15867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15868                         if (r->port_name) {
15869                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15870                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_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->monitor_name) {
15878                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15879                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15880                         }
15881                         ndr->flags = _flags_save_string;
15882                 }
15883                 {
15884                         uint32_t _flags_save_string = ndr->flags;
15885                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15886                         if (r->description) {
15887                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15888                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15889                         }
15890                         ndr->flags = _flags_save_string;
15891                 }
15892         }
15893         return NDR_ERR_SUCCESS;
15894 }
15895
15896 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15897 {
15898         uint32_t _ptr_port_name;
15899         TALLOC_CTX *_mem_save_port_name_0;
15900         uint32_t _ptr_monitor_name;
15901         TALLOC_CTX *_mem_save_monitor_name_0;
15902         uint32_t _ptr_description;
15903         TALLOC_CTX *_mem_save_description_0;
15904         if (ndr_flags & NDR_SCALARS) {
15905                 NDR_CHECK(ndr_pull_align(ndr, 4));
15906                 {
15907                         uint32_t _flags_save_string = ndr->flags;
15908                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15909                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15910                         if (_ptr_port_name) {
15911                                 NDR_PULL_ALLOC(ndr, r->port_name);
15912                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15913                         } else {
15914                                 r->port_name = NULL;
15915                         }
15916                         ndr->flags = _flags_save_string;
15917                 }
15918                 {
15919                         uint32_t _flags_save_string = ndr->flags;
15920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15921                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15922                         if (_ptr_monitor_name) {
15923                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15924                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15925                         } else {
15926                                 r->monitor_name = NULL;
15927                         }
15928                         ndr->flags = _flags_save_string;
15929                 }
15930                 {
15931                         uint32_t _flags_save_string = ndr->flags;
15932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15933                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15934                         if (_ptr_description) {
15935                                 NDR_PULL_ALLOC(ndr, r->description);
15936                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15937                         } else {
15938                                 r->description = NULL;
15939                         }
15940                         ndr->flags = _flags_save_string;
15941                 }
15942                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15944         }
15945         if (ndr_flags & NDR_BUFFERS) {
15946                 {
15947                         uint32_t _flags_save_string = ndr->flags;
15948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15949                         if (r->port_name) {
15950                                 uint32_t _relative_save_offset;
15951                                 _relative_save_offset = ndr->offset;
15952                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15953                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15954                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15955                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15956                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15957                                 ndr->offset = _relative_save_offset;
15958                         }
15959                         ndr->flags = _flags_save_string;
15960                 }
15961                 {
15962                         uint32_t _flags_save_string = ndr->flags;
15963                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15964                         if (r->monitor_name) {
15965                                 uint32_t _relative_save_offset;
15966                                 _relative_save_offset = ndr->offset;
15967                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15968                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15969                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15970                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15971                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15972                                 ndr->offset = _relative_save_offset;
15973                         }
15974                         ndr->flags = _flags_save_string;
15975                 }
15976                 {
15977                         uint32_t _flags_save_string = ndr->flags;
15978                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15979                         if (r->description) {
15980                                 uint32_t _relative_save_offset;
15981                                 _relative_save_offset = ndr->offset;
15982                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15983                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15984                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15985                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15986                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15987                                 ndr->offset = _relative_save_offset;
15988                         }
15989                         ndr->flags = _flags_save_string;
15990                 }
15991         }
15992         return NDR_ERR_SUCCESS;
15993 }
15994
15995 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15996 {
15997         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15998         ndr->depth++;
15999         ndr_print_ptr(ndr, "port_name", r->port_name);
16000         ndr->depth++;
16001         if (r->port_name) {
16002                 ndr_print_string(ndr, "port_name", r->port_name);
16003         }
16004         ndr->depth--;
16005         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16006         ndr->depth++;
16007         if (r->monitor_name) {
16008                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16009         }
16010         ndr->depth--;
16011         ndr_print_ptr(ndr, "description", r->description);
16012         ndr->depth++;
16013         if (r->description) {
16014                 ndr_print_string(ndr, "description", r->description);
16015         }
16016         ndr->depth--;
16017         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
16018         ndr_print_uint32(ndr, "reserved", r->reserved);
16019         ndr->depth--;
16020 }
16021
16022 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16023 {
16024         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
16025 }
16026
16027 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
16028 {
16029         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16030         return NDR_ERR_SUCCESS;
16031 }
16032
16033 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16034 {
16035         uint32_t v;
16036         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16037         *r = v;
16038         return NDR_ERR_SUCCESS;
16039 }
16040
16041 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16042 {
16043         const char *val = NULL;
16044
16045         switch (r) {
16046                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16047                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16048                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16049                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16050                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16051                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16052                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16053                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16054                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16055                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16056                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16057                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16058                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16059         }
16060         ndr_print_enum(ndr, name, "ENUM", val, r);
16061 }
16062
16063 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16064 {
16065         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16066         return NDR_ERR_SUCCESS;
16067 }
16068
16069 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16070 {
16071         uint32_t v;
16072         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16073         *r = v;
16074         return NDR_ERR_SUCCESS;
16075 }
16076
16077 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16078 {
16079         const char *val = NULL;
16080
16081         switch (r) {
16082                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16083                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16084                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16085         }
16086         ndr_print_enum(ndr, name, "ENUM", val, r);
16087 }
16088
16089 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16090 {
16091         if (ndr_flags & NDR_SCALARS) {
16092                 NDR_CHECK(ndr_push_align(ndr, 4));
16093                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16094                 {
16095                         uint32_t _flags_save_string = ndr->flags;
16096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16097                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16098                         ndr->flags = _flags_save_string;
16099                 }
16100                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16101         }
16102         if (ndr_flags & NDR_BUFFERS) {
16103                 {
16104                         uint32_t _flags_save_string = ndr->flags;
16105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16106                         if (r->status_string) {
16107                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16108                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16109                         }
16110                         ndr->flags = _flags_save_string;
16111                 }
16112         }
16113         return NDR_ERR_SUCCESS;
16114 }
16115
16116 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16117 {
16118         uint32_t _ptr_status_string;
16119         TALLOC_CTX *_mem_save_status_string_0;
16120         if (ndr_flags & NDR_SCALARS) {
16121                 NDR_CHECK(ndr_pull_align(ndr, 4));
16122                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16123                 {
16124                         uint32_t _flags_save_string = ndr->flags;
16125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16126                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16127                         if (_ptr_status_string) {
16128                                 NDR_PULL_ALLOC(ndr, r->status_string);
16129                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16130                         } else {
16131                                 r->status_string = NULL;
16132                         }
16133                         ndr->flags = _flags_save_string;
16134                 }
16135                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16136         }
16137         if (ndr_flags & NDR_BUFFERS) {
16138                 {
16139                         uint32_t _flags_save_string = ndr->flags;
16140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16141                         if (r->status_string) {
16142                                 uint32_t _relative_save_offset;
16143                                 _relative_save_offset = ndr->offset;
16144                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16145                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16146                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16147                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16148                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16149                                 ndr->offset = _relative_save_offset;
16150                         }
16151                         ndr->flags = _flags_save_string;
16152                 }
16153         }
16154         return NDR_ERR_SUCCESS;
16155 }
16156
16157 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16158 {
16159         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16160         ndr->depth++;
16161         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16162         ndr_print_ptr(ndr, "status_string", r->status_string);
16163         ndr->depth++;
16164         if (r->status_string) {
16165                 ndr_print_string(ndr, "status_string", r->status_string);
16166         }
16167         ndr->depth--;
16168         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16169         ndr->depth--;
16170 }
16171
16172 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16173 {
16174         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16175 }
16176
16177 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16178 {
16179         if (ndr_flags & NDR_SCALARS) {
16180                 NDR_CHECK(ndr_push_align(ndr, 4));
16181                 {
16182                         uint32_t _flags_save_string = ndr->flags;
16183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16184                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16185                         ndr->flags = _flags_save_string;
16186                 }
16187                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16188         }
16189         if (ndr_flags & NDR_BUFFERS) {
16190                 {
16191                         uint32_t _flags_save_string = ndr->flags;
16192                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16193                         if (r->port_name) {
16194                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16195                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16196                         }
16197                         ndr->flags = _flags_save_string;
16198                 }
16199         }
16200         return NDR_ERR_SUCCESS;
16201 }
16202
16203 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16204 {
16205         uint32_t _ptr_port_name;
16206         TALLOC_CTX *_mem_save_port_name_0;
16207         if (ndr_flags & NDR_SCALARS) {
16208                 NDR_CHECK(ndr_pull_align(ndr, 4));
16209                 {
16210                         uint32_t _flags_save_string = ndr->flags;
16211                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16212                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16213                         if (_ptr_port_name) {
16214                                 NDR_PULL_ALLOC(ndr, r->port_name);
16215                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16216                         } else {
16217                                 r->port_name = NULL;
16218                         }
16219                         ndr->flags = _flags_save_string;
16220                 }
16221                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16222         }
16223         if (ndr_flags & NDR_BUFFERS) {
16224                 {
16225                         uint32_t _flags_save_string = ndr->flags;
16226                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16227                         if (r->port_name) {
16228                                 uint32_t _relative_save_offset;
16229                                 _relative_save_offset = ndr->offset;
16230                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16231                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16232                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16233                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16234                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16235                                 ndr->offset = _relative_save_offset;
16236                         }
16237                         ndr->flags = _flags_save_string;
16238                 }
16239         }
16240         return NDR_ERR_SUCCESS;
16241 }
16242
16243 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16244 {
16245         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16246         ndr->depth++;
16247         ndr_print_ptr(ndr, "port_name", r->port_name);
16248         ndr->depth++;
16249         if (r->port_name) {
16250                 ndr_print_string(ndr, "port_name", r->port_name);
16251         }
16252         ndr->depth--;
16253         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16254         ndr->depth--;
16255 }
16256
16257 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16258 {
16259         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16260 }
16261
16262 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16263 {
16264         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16265         if (ndr_flags & NDR_SCALARS) {
16266                 int level = ndr_push_get_switch_value(ndr, r);
16267                 switch (level) {
16268                         case 1: {
16269                                 NDR_CHECK(ndr_push_align(ndr, 4));
16270                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16271                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16272                         break; }
16273
16274                         case 2: {
16275                                 NDR_CHECK(ndr_push_align(ndr, 4));
16276                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16277                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16278                         break; }
16279
16280                         case 3: {
16281                                 NDR_CHECK(ndr_push_align(ndr, 4));
16282                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16283                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16284                         break; }
16285
16286                         case 0xff: {
16287                                 NDR_CHECK(ndr_push_align(ndr, 4));
16288                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16289                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16290                         break; }
16291
16292                         default: {
16293                         break; }
16294
16295                 }
16296         }
16297         if (ndr_flags & NDR_BUFFERS) {
16298                 int level = ndr_push_get_switch_value(ndr, r);
16299                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16300                 switch (level) {
16301                         case 1:
16302                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16303                         break;
16304
16305                         case 2:
16306                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16307                         break;
16308
16309                         case 3:
16310                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16311                         break;
16312
16313                         case 0xff:
16314                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16315                         break;
16316
16317                         default:
16318                         break;
16319
16320                 }
16321         }
16322         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16323         return NDR_ERR_SUCCESS;
16324 }
16325
16326 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16327 {
16328         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16329         int level;
16330         level = ndr_pull_get_switch_value(ndr, r);
16331         if (ndr_flags & NDR_SCALARS) {
16332                 switch (level) {
16333                         case 1: {
16334                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16335                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16336                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16337                         break; }
16338
16339                         case 2: {
16340                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16341                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16342                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16343                         break; }
16344
16345                         case 3: {
16346                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16347                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16348                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16349                         break; }
16350
16351                         case 0xff: {
16352                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16353                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16354                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16355                         break; }
16356
16357                         default: {
16358                         break; }
16359
16360                 }
16361         }
16362         if (ndr_flags & NDR_BUFFERS) {
16363                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16364                 switch (level) {
16365                         case 1:
16366                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16367                         break;
16368
16369                         case 2:
16370                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16371                         break;
16372
16373                         case 3:
16374                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16375                         break;
16376
16377                         case 0xff:
16378                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16379                         break;
16380
16381                         default:
16382                         break;
16383
16384                 }
16385         }
16386         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16387         return NDR_ERR_SUCCESS;
16388 }
16389
16390 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16391 {
16392         int level;
16393         level = ndr_print_get_switch_value(ndr, r);
16394         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16395         switch (level) {
16396                 case 1:
16397                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16398                 break;
16399
16400                 case 2:
16401                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16402                 break;
16403
16404                 case 3:
16405                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16406                 break;
16407
16408                 case 0xff:
16409                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16410                 break;
16411
16412                 default:
16413                 break;
16414
16415         }
16416 }
16417
16418 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16419 {
16420         if (ndr_flags & NDR_SCALARS) {
16421                 NDR_CHECK(ndr_push_align(ndr, 4));
16422                 {
16423                         uint32_t _flags_save_string = ndr->flags;
16424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16425                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16426                         ndr->flags = _flags_save_string;
16427                 }
16428         }
16429         if (ndr_flags & NDR_BUFFERS) {
16430                 {
16431                         uint32_t _flags_save_string = ndr->flags;
16432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16433                         if (r->monitor_name) {
16434                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16435                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16436                         }
16437                         ndr->flags = _flags_save_string;
16438                 }
16439         }
16440         return NDR_ERR_SUCCESS;
16441 }
16442
16443 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16444 {
16445         uint32_t _ptr_monitor_name;
16446         TALLOC_CTX *_mem_save_monitor_name_0;
16447         if (ndr_flags & NDR_SCALARS) {
16448                 NDR_CHECK(ndr_pull_align(ndr, 4));
16449                 {
16450                         uint32_t _flags_save_string = ndr->flags;
16451                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16452                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16453                         if (_ptr_monitor_name) {
16454                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16455                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16456                         } else {
16457                                 r->monitor_name = NULL;
16458                         }
16459                         ndr->flags = _flags_save_string;
16460                 }
16461         }
16462         if (ndr_flags & NDR_BUFFERS) {
16463                 {
16464                         uint32_t _flags_save_string = ndr->flags;
16465                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16466                         if (r->monitor_name) {
16467                                 uint32_t _relative_save_offset;
16468                                 _relative_save_offset = ndr->offset;
16469                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16470                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16471                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16472                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16473                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16474                                 ndr->offset = _relative_save_offset;
16475                         }
16476                         ndr->flags = _flags_save_string;
16477                 }
16478         }
16479         return NDR_ERR_SUCCESS;
16480 }
16481
16482 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16483 {
16484         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16485         ndr->depth++;
16486         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16487         ndr->depth++;
16488         if (r->monitor_name) {
16489                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16490         }
16491         ndr->depth--;
16492         ndr->depth--;
16493 }
16494
16495 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16496 {
16497         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16498 }
16499
16500 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16501 {
16502         if (ndr_flags & NDR_SCALARS) {
16503                 NDR_CHECK(ndr_push_align(ndr, 4));
16504                 {
16505                         uint32_t _flags_save_string = ndr->flags;
16506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16507                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16508                         ndr->flags = _flags_save_string;
16509                 }
16510                 {
16511                         uint32_t _flags_save_string = ndr->flags;
16512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16513                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16514                         ndr->flags = _flags_save_string;
16515                 }
16516                 {
16517                         uint32_t _flags_save_string = ndr->flags;
16518                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16519                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16520                         ndr->flags = _flags_save_string;
16521                 }
16522         }
16523         if (ndr_flags & NDR_BUFFERS) {
16524                 {
16525                         uint32_t _flags_save_string = ndr->flags;
16526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16527                         if (r->monitor_name) {
16528                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16529                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
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->environment) {
16537                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16538                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16539                         }
16540                         ndr->flags = _flags_save_string;
16541                 }
16542                 {
16543                         uint32_t _flags_save_string = ndr->flags;
16544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16545                         if (r->dll_name) {
16546                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16547                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16548                         }
16549                         ndr->flags = _flags_save_string;
16550                 }
16551         }
16552         return NDR_ERR_SUCCESS;
16553 }
16554
16555 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16556 {
16557         uint32_t _ptr_monitor_name;
16558         TALLOC_CTX *_mem_save_monitor_name_0;
16559         uint32_t _ptr_environment;
16560         TALLOC_CTX *_mem_save_environment_0;
16561         uint32_t _ptr_dll_name;
16562         TALLOC_CTX *_mem_save_dll_name_0;
16563         if (ndr_flags & NDR_SCALARS) {
16564                 NDR_CHECK(ndr_pull_align(ndr, 4));
16565                 {
16566                         uint32_t _flags_save_string = ndr->flags;
16567                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16568                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16569                         if (_ptr_monitor_name) {
16570                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16571                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16572                         } else {
16573                                 r->monitor_name = NULL;
16574                         }
16575                         ndr->flags = _flags_save_string;
16576                 }
16577                 {
16578                         uint32_t _flags_save_string = ndr->flags;
16579                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16580                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16581                         if (_ptr_environment) {
16582                                 NDR_PULL_ALLOC(ndr, r->environment);
16583                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16584                         } else {
16585                                 r->environment = NULL;
16586                         }
16587                         ndr->flags = _flags_save_string;
16588                 }
16589                 {
16590                         uint32_t _flags_save_string = ndr->flags;
16591                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16592                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16593                         if (_ptr_dll_name) {
16594                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16595                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16596                         } else {
16597                                 r->dll_name = NULL;
16598                         }
16599                         ndr->flags = _flags_save_string;
16600                 }
16601         }
16602         if (ndr_flags & NDR_BUFFERS) {
16603                 {
16604                         uint32_t _flags_save_string = ndr->flags;
16605                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16606                         if (r->monitor_name) {
16607                                 uint32_t _relative_save_offset;
16608                                 _relative_save_offset = ndr->offset;
16609                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16610                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16611                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16612                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16613                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16614                                 ndr->offset = _relative_save_offset;
16615                         }
16616                         ndr->flags = _flags_save_string;
16617                 }
16618                 {
16619                         uint32_t _flags_save_string = ndr->flags;
16620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16621                         if (r->environment) {
16622                                 uint32_t _relative_save_offset;
16623                                 _relative_save_offset = ndr->offset;
16624                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16625                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16626                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16627                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16628                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16629                                 ndr->offset = _relative_save_offset;
16630                         }
16631                         ndr->flags = _flags_save_string;
16632                 }
16633                 {
16634                         uint32_t _flags_save_string = ndr->flags;
16635                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16636                         if (r->dll_name) {
16637                                 uint32_t _relative_save_offset;
16638                                 _relative_save_offset = ndr->offset;
16639                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16640                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16641                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16642                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16643                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16644                                 ndr->offset = _relative_save_offset;
16645                         }
16646                         ndr->flags = _flags_save_string;
16647                 }
16648         }
16649         return NDR_ERR_SUCCESS;
16650 }
16651
16652 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16653 {
16654         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16655         ndr->depth++;
16656         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16657         ndr->depth++;
16658         if (r->monitor_name) {
16659                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16660         }
16661         ndr->depth--;
16662         ndr_print_ptr(ndr, "environment", r->environment);
16663         ndr->depth++;
16664         if (r->environment) {
16665                 ndr_print_string(ndr, "environment", r->environment);
16666         }
16667         ndr->depth--;
16668         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16669         ndr->depth++;
16670         if (r->dll_name) {
16671                 ndr_print_string(ndr, "dll_name", r->dll_name);
16672         }
16673         ndr->depth--;
16674         ndr->depth--;
16675 }
16676
16677 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16678 {
16679         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16680 }
16681
16682 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16683 {
16684         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16685         if (ndr_flags & NDR_SCALARS) {
16686                 int level = ndr_push_get_switch_value(ndr, r);
16687                 switch (level) {
16688                         case 1: {
16689                                 NDR_CHECK(ndr_push_align(ndr, 4));
16690                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16691                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16692                         break; }
16693
16694                         case 2: {
16695                                 NDR_CHECK(ndr_push_align(ndr, 4));
16696                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16697                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16698                         break; }
16699
16700                         default: {
16701                         break; }
16702
16703                 }
16704         }
16705         if (ndr_flags & NDR_BUFFERS) {
16706                 int level = ndr_push_get_switch_value(ndr, r);
16707                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16708                 switch (level) {
16709                         case 1:
16710                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16711                         break;
16712
16713                         case 2:
16714                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16715                         break;
16716
16717                         default:
16718                         break;
16719
16720                 }
16721         }
16722         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16723         return NDR_ERR_SUCCESS;
16724 }
16725
16726 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16727 {
16728         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16729         int level;
16730         level = ndr_pull_get_switch_value(ndr, r);
16731         if (ndr_flags & NDR_SCALARS) {
16732                 switch (level) {
16733                         case 1: {
16734                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16735                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16736                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16737                         break; }
16738
16739                         case 2: {
16740                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16741                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16742                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16743                         break; }
16744
16745                         default: {
16746                         break; }
16747
16748                 }
16749         }
16750         if (ndr_flags & NDR_BUFFERS) {
16751                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16752                 switch (level) {
16753                         case 1:
16754                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16755                         break;
16756
16757                         case 2:
16758                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16759                         break;
16760
16761                         default:
16762                         break;
16763
16764                 }
16765         }
16766         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16767         return NDR_ERR_SUCCESS;
16768 }
16769
16770 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16771 {
16772         int level;
16773         level = ndr_print_get_switch_value(ndr, r);
16774         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16775         switch (level) {
16776                 case 1:
16777                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16778                 break;
16779
16780                 case 2:
16781                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16782                 break;
16783
16784                 default:
16785                 break;
16786
16787         }
16788 }
16789
16790 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16791 {
16792         if (ndr_flags & NDR_SCALARS) {
16793                 NDR_CHECK(ndr_push_align(ndr, 4));
16794                 {
16795                         uint32_t _flags_save_string = ndr->flags;
16796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16797                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16798                         ndr->flags = _flags_save_string;
16799                 }
16800         }
16801         if (ndr_flags & NDR_BUFFERS) {
16802                 {
16803                         uint32_t _flags_save_string = ndr->flags;
16804                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16805                         if (r->name_array) {
16806                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16807                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16808                         }
16809                         ndr->flags = _flags_save_string;
16810                 }
16811         }
16812         return NDR_ERR_SUCCESS;
16813 }
16814
16815 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16816 {
16817         uint32_t _ptr_name_array;
16818         TALLOC_CTX *_mem_save_name_array_0;
16819         if (ndr_flags & NDR_SCALARS) {
16820                 NDR_CHECK(ndr_pull_align(ndr, 4));
16821                 {
16822                         uint32_t _flags_save_string = ndr->flags;
16823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16824                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16825                         if (_ptr_name_array) {
16826                                 NDR_PULL_ALLOC(ndr, r->name_array);
16827                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16828                         } else {
16829                                 r->name_array = NULL;
16830                         }
16831                         ndr->flags = _flags_save_string;
16832                 }
16833         }
16834         if (ndr_flags & NDR_BUFFERS) {
16835                 {
16836                         uint32_t _flags_save_string = ndr->flags;
16837                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16838                         if (r->name_array) {
16839                                 uint32_t _relative_save_offset;
16840                                 _relative_save_offset = ndr->offset;
16841                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16842                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16843                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16844                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16845                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16846                                 ndr->offset = _relative_save_offset;
16847                         }
16848                         ndr->flags = _flags_save_string;
16849                 }
16850         }
16851         return NDR_ERR_SUCCESS;
16852 }
16853
16854 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16855 {
16856         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16857         ndr->depth++;
16858         ndr_print_ptr(ndr, "name_array", r->name_array);
16859         ndr->depth++;
16860         if (r->name_array) {
16861                 ndr_print_string(ndr, "name_array", r->name_array);
16862         }
16863         ndr->depth--;
16864         ndr->depth--;
16865 }
16866
16867 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16868 {
16869         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16870 }
16871
16872 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16873 {
16874         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16875         if (ndr_flags & NDR_SCALARS) {
16876                 int level = ndr_push_get_switch_value(ndr, r);
16877                 switch (level) {
16878                         case 1: {
16879                                 NDR_CHECK(ndr_push_align(ndr, 4));
16880                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16881                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16882                         break; }
16883
16884                         default: {
16885                         break; }
16886
16887                 }
16888         }
16889         if (ndr_flags & NDR_BUFFERS) {
16890                 int level = ndr_push_get_switch_value(ndr, r);
16891                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16892                 switch (level) {
16893                         case 1:
16894                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16895                         break;
16896
16897                         default:
16898                         break;
16899
16900                 }
16901         }
16902         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16903         return NDR_ERR_SUCCESS;
16904 }
16905
16906 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16907 {
16908         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16909         int level;
16910         level = ndr_pull_get_switch_value(ndr, r);
16911         if (ndr_flags & NDR_SCALARS) {
16912                 switch (level) {
16913                         case 1: {
16914                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16915                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16916                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16917                         break; }
16918
16919                         default: {
16920                         break; }
16921
16922                 }
16923         }
16924         if (ndr_flags & NDR_BUFFERS) {
16925                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16926                 switch (level) {
16927                         case 1:
16928                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16929                         break;
16930
16931                         default:
16932                         break;
16933
16934                 }
16935         }
16936         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16937         return NDR_ERR_SUCCESS;
16938 }
16939
16940 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16941 {
16942         int level;
16943         level = ndr_print_get_switch_value(ndr, r);
16944         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16945         switch (level) {
16946                 case 1:
16947                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16948                 break;
16949
16950                 default:
16951                 break;
16952
16953         }
16954 }
16955
16956 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16957 {
16958         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16959         return NDR_ERR_SUCCESS;
16960 }
16961
16962 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16963 {
16964         uint32_t v;
16965         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16966         *r = v;
16967         return NDR_ERR_SUCCESS;
16968 }
16969
16970 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16971 {
16972         ndr_print_uint32(ndr, name, r);
16973         ndr->depth++;
16974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16985         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16986         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16987         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16988         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16989         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16990         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16991         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16992         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16993         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16994         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16995         ndr->depth--;
16996 }
16997
16998 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
16999 {
17000         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17001         return NDR_ERR_SUCCESS;
17002 }
17003
17004 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
17005 {
17006         uint16_t v;
17007         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17008         *r = v;
17009         return NDR_ERR_SUCCESS;
17010 }
17011
17012 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
17013 {
17014         const char *val = NULL;
17015
17016         switch (r) {
17017                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
17018                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
17019                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
17020                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
17021                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
17022                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
17023                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17024                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
17025                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
17026                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
17027                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
17028                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
17029                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17030                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
17031                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
17032                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
17033                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
17034                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
17035                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
17036                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
17037                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
17038                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
17039                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
17040                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
17041         }
17042         ndr_print_enum(ndr, name, "ENUM", val, r);
17043 }
17044
17045 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
17046 {
17047         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17048         return NDR_ERR_SUCCESS;
17049 }
17050
17051 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
17052 {
17053         uint16_t v;
17054         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17055         *r = v;
17056         return NDR_ERR_SUCCESS;
17057 }
17058
17059 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
17060 {
17061         const char *val = NULL;
17062
17063         switch (r) {
17064                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
17065                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
17066                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
17067                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
17068                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
17069                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
17070                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
17071                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
17072                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
17073                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17074                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
17075                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
17076                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17077                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
17078                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
17079                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
17080                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
17081                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
17082                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
17083                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
17084                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
17085                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
17086                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
17087                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
17088                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
17089                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
17090                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
17091                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
17092         }
17093         ndr_print_enum(ndr, name, "ENUM", val, r);
17094 }
17095
17096 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17097 {
17098         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17099         return NDR_ERR_SUCCESS;
17100 }
17101
17102 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17103 {
17104         uint16_t v;
17105         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17106         *r = v;
17107         return NDR_ERR_SUCCESS;
17108 }
17109
17110 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17111 {
17112         const char *val = NULL;
17113
17114         switch (r) {
17115                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17116                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17117         }
17118         ndr_print_enum(ndr, name, "ENUM", val, r);
17119 }
17120
17121 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
17122 {
17123         if (ndr_flags & NDR_SCALARS) {
17124                 int level = ndr_push_get_switch_value(ndr, r);
17125                 switch (level) {
17126                         case PRINTER_NOTIFY_TYPE: {
17127                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17128                         break; }
17129
17130                         case JOB_NOTIFY_TYPE: {
17131                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17132                         break; }
17133
17134                         default: {
17135                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17136                         break; }
17137
17138                 }
17139         }
17140         if (ndr_flags & NDR_BUFFERS) {
17141                 int level = ndr_push_get_switch_value(ndr, r);
17142                 switch (level) {
17143                         case PRINTER_NOTIFY_TYPE:
17144                         break;
17145
17146                         case JOB_NOTIFY_TYPE:
17147                         break;
17148
17149                         default:
17150                         break;
17151
17152                 }
17153         }
17154         return NDR_ERR_SUCCESS;
17155 }
17156
17157 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
17158 {
17159         int level;
17160         level = ndr_pull_get_switch_value(ndr, r);
17161         if (ndr_flags & NDR_SCALARS) {
17162                 switch (level) {
17163                         case PRINTER_NOTIFY_TYPE: {
17164                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17165                         break; }
17166
17167                         case JOB_NOTIFY_TYPE: {
17168                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17169                         break; }
17170
17171                         default: {
17172                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17173                         break; }
17174
17175                 }
17176         }
17177         if (ndr_flags & NDR_BUFFERS) {
17178                 switch (level) {
17179                         case PRINTER_NOTIFY_TYPE:
17180                         break;
17181
17182                         case JOB_NOTIFY_TYPE:
17183                         break;
17184
17185                         default:
17186                         break;
17187
17188                 }
17189         }
17190         return NDR_ERR_SUCCESS;
17191 }
17192
17193 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17194 {
17195         uint32_t cntr_fields_1;
17196         if (ndr_flags & NDR_SCALARS) {
17197                 NDR_CHECK(ndr_push_align(ndr, 4));
17198                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17199                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17203                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17204         }
17205         if (ndr_flags & NDR_BUFFERS) {
17206                 if (r->fields) {
17207                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17208                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17209                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17210                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17211                         }
17212                 }
17213         }
17214         return NDR_ERR_SUCCESS;
17215 }
17216
17217 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17218 {
17219         uint32_t _ptr_fields;
17220         uint32_t cntr_fields_1;
17221         TALLOC_CTX *_mem_save_fields_0;
17222         TALLOC_CTX *_mem_save_fields_1;
17223         if (ndr_flags & NDR_SCALARS) {
17224                 NDR_CHECK(ndr_pull_align(ndr, 4));
17225                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17226                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17227                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17231                 if (_ptr_fields) {
17232                         NDR_PULL_ALLOC(ndr, r->fields);
17233                 } else {
17234                         r->fields = NULL;
17235                 }
17236         }
17237         if (ndr_flags & NDR_BUFFERS) {
17238                 if (r->fields) {
17239                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17240                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17241                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17242                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17243                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17244                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17245                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17246                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17247                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17248                         }
17249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17251                 }
17252                 if (r->fields) {
17253                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17254                 }
17255         }
17256         return NDR_ERR_SUCCESS;
17257 }
17258
17259 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17260 {
17261         uint32_t cntr_fields_1;
17262         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17263         ndr->depth++;
17264         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17265         ndr_print_uint16(ndr, "u1", r->u1);
17266         ndr_print_uint32(ndr, "u2", r->u2);
17267         ndr_print_uint32(ndr, "u3", r->u3);
17268         ndr_print_uint32(ndr, "count", r->count);
17269         ndr_print_ptr(ndr, "fields", r->fields);
17270         ndr->depth++;
17271         if (r->fields) {
17272                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17273                 ndr->depth++;
17274                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17275                         char *idx_1=NULL;
17276                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17277                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
17278                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
17279                                 free(idx_1);
17280                         }
17281                 }
17282                 ndr->depth--;
17283         }
17284         ndr->depth--;
17285         ndr->depth--;
17286 }
17287
17288 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17289 {
17290         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17291         return NDR_ERR_SUCCESS;
17292 }
17293
17294 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17295 {
17296         uint32_t v;
17297         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17298         *r = v;
17299         return NDR_ERR_SUCCESS;
17300 }
17301
17302 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17303 {
17304         ndr_print_uint32(ndr, name, r);
17305         ndr->depth++;
17306         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17307         ndr->depth--;
17308 }
17309
17310 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17311 {
17312         uint32_t cntr_types_1;
17313         if (ndr_flags & NDR_SCALARS) {
17314                 NDR_CHECK(ndr_push_align(ndr, 4));
17315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17316                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17318                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17319         }
17320         if (ndr_flags & NDR_BUFFERS) {
17321                 if (r->types) {
17322                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17323                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17324                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17325                         }
17326                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17327                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17328                         }
17329                 }
17330         }
17331         return NDR_ERR_SUCCESS;
17332 }
17333
17334 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17335 {
17336         uint32_t _ptr_types;
17337         uint32_t cntr_types_1;
17338         TALLOC_CTX *_mem_save_types_0;
17339         TALLOC_CTX *_mem_save_types_1;
17340         if (ndr_flags & NDR_SCALARS) {
17341                 NDR_CHECK(ndr_pull_align(ndr, 4));
17342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17343                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17344                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17346                 if (_ptr_types) {
17347                         NDR_PULL_ALLOC(ndr, r->types);
17348                 } else {
17349                         r->types = NULL;
17350                 }
17351         }
17352         if (ndr_flags & NDR_BUFFERS) {
17353                 if (r->types) {
17354                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17355                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17357                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17358                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17359                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17360                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17361                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17362                         }
17363                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17364                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17365                         }
17366                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17368                 }
17369                 if (r->types) {
17370                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17371                 }
17372         }
17373         return NDR_ERR_SUCCESS;
17374 }
17375
17376 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17377 {
17378         uint32_t cntr_types_1;
17379         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17380         ndr->depth++;
17381         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17382         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17383         ndr_print_uint32(ndr, "count", r->count);
17384         ndr_print_ptr(ndr, "types", r->types);
17385         ndr->depth++;
17386         if (r->types) {
17387                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17388                 ndr->depth++;
17389                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17390                         char *idx_1=NULL;
17391                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17392                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17393                                 free(idx_1);
17394                         }
17395                 }
17396                 ndr->depth--;
17397         }
17398         ndr->depth--;
17399         ndr->depth--;
17400 }
17401
17402 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17403 {
17404         if (ndr_flags & NDR_SCALARS) {
17405                 NDR_CHECK(ndr_push_align(ndr, 4));
17406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17408         }
17409         if (ndr_flags & NDR_BUFFERS) {
17410                 if (r->string) {
17411                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17412                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17413                 }
17414         }
17415         return NDR_ERR_SUCCESS;
17416 }
17417
17418 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17419 {
17420         uint32_t _ptr_string;
17421         TALLOC_CTX *_mem_save_string_0;
17422         if (ndr_flags & NDR_SCALARS) {
17423                 NDR_CHECK(ndr_pull_align(ndr, 4));
17424                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17425                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17426                 if (_ptr_string) {
17427                         NDR_PULL_ALLOC(ndr, r->string);
17428                 } else {
17429                         r->string = NULL;
17430                 }
17431         }
17432         if (ndr_flags & NDR_BUFFERS) {
17433                 if (r->string) {
17434                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17435                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17436                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17439                 }
17440                 if (r->string) {
17441                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17442                 }
17443         }
17444         return NDR_ERR_SUCCESS;
17445 }
17446
17447 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17448 {
17449         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17450         ndr->depth++;
17451         ndr_print_uint32(ndr, "size", r->size);
17452         ndr_print_ptr(ndr, "string", r->string);
17453         ndr->depth++;
17454         if (r->string) {
17455                 ndr_print_string(ndr, "string", r->string);
17456         }
17457         ndr->depth--;
17458         ndr->depth--;
17459 }
17460
17461 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17462 {
17463         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17464         return NDR_ERR_SUCCESS;
17465 }
17466
17467 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17468 {
17469         uint32_t v;
17470         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17471         *r = v;
17472         return NDR_ERR_SUCCESS;
17473 }
17474
17475 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17476 {
17477         const char *val = NULL;
17478
17479         switch (r) {
17480                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17481                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17482                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17483                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17484                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17485         }
17486         ndr_print_enum(ndr, name, "ENUM", val, r);
17487 }
17488
17489 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17490 {
17491         if (ndr_flags & NDR_SCALARS) {
17492                 int level = ndr_push_get_switch_value(ndr, r);
17493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17494                 switch (level) {
17495                         case 1: {
17496                                 uint32_t cntr_integer_0;
17497                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17498                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17499                                 }
17500                         break; }
17501
17502                         case 2: {
17503                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17504                         break; }
17505
17506                         case 3: {
17507                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17508                         break; }
17509
17510                         case 4: {
17511                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17512                         break; }
17513
17514                         case 5: {
17515                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17516                         break; }
17517
17518                         default:
17519                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17520                 }
17521         }
17522         if (ndr_flags & NDR_BUFFERS) {
17523                 int level = ndr_push_get_switch_value(ndr, r);
17524                 switch (level) {
17525                         case 1:
17526                         break;
17527
17528                         case 2:
17529                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17530                         break;
17531
17532                         case 3:
17533                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17534                         break;
17535
17536                         case 4:
17537                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17538                         break;
17539
17540                         case 5:
17541                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17542                         break;
17543
17544                         default:
17545                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17546                 }
17547         }
17548         return NDR_ERR_SUCCESS;
17549 }
17550
17551 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17552 {
17553         int level;
17554         uint32_t _level;
17555         level = ndr_pull_get_switch_value(ndr, r);
17556         if (ndr_flags & NDR_SCALARS) {
17557                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17558                 if (_level != level) {
17559                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17560                 }
17561                 switch (level) {
17562                         case 1: {
17563                                 uint32_t cntr_integer_0;
17564                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17565                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17566                                 }
17567                         break; }
17568
17569                         case 2: {
17570                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17571                         break; }
17572
17573                         case 3: {
17574                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17575                         break; }
17576
17577                         case 4: {
17578                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17579                         break; }
17580
17581                         case 5: {
17582                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17583                         break; }
17584
17585                         default:
17586                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17587                 }
17588         }
17589         if (ndr_flags & NDR_BUFFERS) {
17590                 switch (level) {
17591                         case 1:
17592                         break;
17593
17594                         case 2:
17595                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17596                         break;
17597
17598                         case 3:
17599                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17600                         break;
17601
17602                         case 4:
17603                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17604                         break;
17605
17606                         case 5:
17607                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17608                         break;
17609
17610                         default:
17611                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17612                 }
17613         }
17614         return NDR_ERR_SUCCESS;
17615 }
17616
17617 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17618 {
17619         int level;
17620         uint32_t cntr_integer_0;
17621         level = ndr_print_get_switch_value(ndr, r);
17622         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17623         switch (level) {
17624                 case 1:
17625                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17626                         ndr->depth++;
17627                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17628                                 char *idx_0=NULL;
17629                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17630                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17631                                         free(idx_0);
17632                                 }
17633                         }
17634                         ndr->depth--;
17635                 break;
17636
17637                 case 2:
17638                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17639                 break;
17640
17641                 case 3:
17642                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17643                 break;
17644
17645                 case 4:
17646                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17647                 break;
17648
17649                 case 5:
17650                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17651                 break;
17652
17653                 default:
17654                         ndr_print_bad_level(ndr, name, level);
17655         }
17656 }
17657
17658 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17659 {
17660         if (ndr_flags & NDR_SCALARS) {
17661                 NDR_CHECK(ndr_push_align(ndr, 4));
17662                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17663                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
17664                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17665                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17667                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17668                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17669         }
17670         if (ndr_flags & NDR_BUFFERS) {
17671                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17672         }
17673         return NDR_ERR_SUCCESS;
17674 }
17675
17676 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17677 {
17678         if (ndr_flags & NDR_SCALARS) {
17679                 NDR_CHECK(ndr_pull_align(ndr, 4));
17680                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17681                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
17682                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17683                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17685                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17686                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17687         }
17688         if (ndr_flags & NDR_BUFFERS) {
17689                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17690         }
17691         return NDR_ERR_SUCCESS;
17692 }
17693
17694 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17695 {
17696         ndr_print_struct(ndr, name, "spoolss_Notify");
17697         ndr->depth++;
17698         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17699         ndr_print_set_switch_value(ndr, &r->field, r->type);
17700         ndr_print_spoolss_Field(ndr, "field", &r->field);
17701         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17702         ndr_print_uint32(ndr, "job_id", r->job_id);
17703         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17704         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17705         ndr->depth--;
17706 }
17707
17708 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17709 {
17710         uint32_t cntr_notifies_0;
17711         if (ndr_flags & NDR_SCALARS) {
17712                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17713                 NDR_CHECK(ndr_push_align(ndr, 4));
17714                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17715                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17716                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17717                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17718                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17719                 }
17720         }
17721         if (ndr_flags & NDR_BUFFERS) {
17722                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17723                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17724                 }
17725         }
17726         return NDR_ERR_SUCCESS;
17727 }
17728
17729 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17730 {
17731         uint32_t cntr_notifies_0;
17732         TALLOC_CTX *_mem_save_notifies_0;
17733         if (ndr_flags & NDR_SCALARS) {
17734                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17735                 NDR_CHECK(ndr_pull_align(ndr, 4));
17736                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17737                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17738                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17739                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17740                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17741                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17742                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17743                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17744                 }
17745                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17746                 if (r->notifies) {
17747                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17748                 }
17749         }
17750         if (ndr_flags & NDR_BUFFERS) {
17751                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17752                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17753                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17754                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17755                 }
17756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17757         }
17758         return NDR_ERR_SUCCESS;
17759 }
17760
17761 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17762 {
17763         uint32_t cntr_notifies_0;
17764         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17765         ndr->depth++;
17766         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17767         ndr_print_uint32(ndr, "flags", r->flags);
17768         ndr_print_uint32(ndr, "count", r->count);
17769         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17770         ndr->depth++;
17771         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17772                 char *idx_0=NULL;
17773                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17774                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17775                         free(idx_0);
17776                 }
17777         }
17778         ndr->depth--;
17779         ndr->depth--;
17780 }
17781
17782 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17783 {
17784         if (ndr_flags & NDR_SCALARS) {
17785                 int level = ndr_push_get_switch_value(ndr, r);
17786                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17787                 switch (level) {
17788                         case 0: {
17789                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17790                         break; }
17791
17792                         default:
17793                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17794                 }
17795         }
17796         if (ndr_flags & NDR_BUFFERS) {
17797                 int level = ndr_push_get_switch_value(ndr, r);
17798                 switch (level) {
17799                         case 0:
17800                                 if (r->info0) {
17801                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17802                                 }
17803                         break;
17804
17805                         default:
17806                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17807                 }
17808         }
17809         return NDR_ERR_SUCCESS;
17810 }
17811
17812 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17813 {
17814         int level;
17815         uint32_t _level;
17816         TALLOC_CTX *_mem_save_info0_0;
17817         level = ndr_pull_get_switch_value(ndr, r);
17818         if (ndr_flags & NDR_SCALARS) {
17819                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17820                 if (_level != level) {
17821                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17822                 }
17823                 switch (level) {
17824                         case 0: {
17825                                 uint32_t _ptr_info0;
17826                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17827                                 if (_ptr_info0) {
17828                                         NDR_PULL_ALLOC(ndr, r->info0);
17829                                 } else {
17830                                         r->info0 = NULL;
17831                                 }
17832                         break; }
17833
17834                         default:
17835                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17836                 }
17837         }
17838         if (ndr_flags & NDR_BUFFERS) {
17839                 switch (level) {
17840                         case 0:
17841                                 if (r->info0) {
17842                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17843                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17844                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17845                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17846                                 }
17847                         break;
17848
17849                         default:
17850                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17851                 }
17852         }
17853         return NDR_ERR_SUCCESS;
17854 }
17855
17856 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17857 {
17858         int level;
17859         level = ndr_print_get_switch_value(ndr, r);
17860         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17861         switch (level) {
17862                 case 0:
17863                         ndr_print_ptr(ndr, "info0", r->info0);
17864                         ndr->depth++;
17865                         if (r->info0) {
17866                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17867                         }
17868                         ndr->depth--;
17869                 break;
17870
17871                 default:
17872                         ndr_print_bad_level(ndr, name, level);
17873         }
17874 }
17875
17876 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17877 {
17878         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17879         return NDR_ERR_SUCCESS;
17880 }
17881
17882 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17883 {
17884         uint32_t v;
17885         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17886         *r = v;
17887         return NDR_ERR_SUCCESS;
17888 }
17889
17890 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17891 {
17892         ndr_print_uint32(ndr, name, r);
17893         ndr->depth++;
17894         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17895         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17896         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17897         ndr->depth--;
17898 }
17899
17900 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17901 {
17902         if (ndr_flags & NDR_SCALARS) {
17903                 NDR_CHECK(ndr_push_align(ndr, 4));
17904                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17908                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17909                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17910                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17911         }
17912         if (ndr_flags & NDR_BUFFERS) {
17913                 if (r->client) {
17914                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17917                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17918                 }
17919                 if (r->user) {
17920                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17923                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17924                 }
17925         }
17926         return NDR_ERR_SUCCESS;
17927 }
17928
17929 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17930 {
17931         uint32_t _ptr_client;
17932         TALLOC_CTX *_mem_save_client_0;
17933         uint32_t _ptr_user;
17934         TALLOC_CTX *_mem_save_user_0;
17935         if (ndr_flags & NDR_SCALARS) {
17936                 NDR_CHECK(ndr_pull_align(ndr, 4));
17937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17938                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17939                 if (_ptr_client) {
17940                         NDR_PULL_ALLOC(ndr, r->client);
17941                 } else {
17942                         r->client = NULL;
17943                 }
17944                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17945                 if (_ptr_user) {
17946                         NDR_PULL_ALLOC(ndr, r->user);
17947                 } else {
17948                         r->user = NULL;
17949                 }
17950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17951                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17952                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17953                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17954         }
17955         if (ndr_flags & NDR_BUFFERS) {
17956                 if (r->client) {
17957                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17958                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17959                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17960                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17961                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17962                                 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));
17963                         }
17964                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17965                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17966                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17967                 }
17968                 if (r->user) {
17969                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17970                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17971                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17972                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17973                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17974                                 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));
17975                         }
17976                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17977                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17978                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17979                 }
17980         }
17981         return NDR_ERR_SUCCESS;
17982 }
17983
17984 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17985 {
17986         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17987         ndr->depth++;
17988         ndr_print_uint32(ndr, "size", r->size);
17989         ndr_print_ptr(ndr, "client", r->client);
17990         ndr->depth++;
17991         if (r->client) {
17992                 ndr_print_string(ndr, "client", r->client);
17993         }
17994         ndr->depth--;
17995         ndr_print_ptr(ndr, "user", r->user);
17996         ndr->depth++;
17997         if (r->user) {
17998                 ndr_print_string(ndr, "user", r->user);
17999         }
18000         ndr->depth--;
18001         ndr_print_uint32(ndr, "build", r->build);
18002         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18003         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18004         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18005         ndr->depth--;
18006 }
18007
18008 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
18009 {
18010         if (ndr_flags & NDR_SCALARS) {
18011                 NDR_CHECK(ndr_push_align(ndr, 4));
18012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
18013         }
18014         if (ndr_flags & NDR_BUFFERS) {
18015         }
18016         return NDR_ERR_SUCCESS;
18017 }
18018
18019 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
18020 {
18021         if (ndr_flags & NDR_SCALARS) {
18022                 NDR_CHECK(ndr_pull_align(ndr, 4));
18023                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
18024         }
18025         if (ndr_flags & NDR_BUFFERS) {
18026         }
18027         return NDR_ERR_SUCCESS;
18028 }
18029
18030 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
18031 {
18032         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
18033         ndr->depth++;
18034         ndr_print_uint32(ndr, "not_used", r->not_used);
18035         ndr->depth--;
18036 }
18037
18038 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
18039 {
18040         if (ndr_flags & NDR_SCALARS) {
18041                 NDR_CHECK(ndr_push_align(ndr, 4));
18042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
18045                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18046                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18048                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18049                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18050                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18051                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
18052         }
18053         if (ndr_flags & NDR_BUFFERS) {
18054                 if (r->client) {
18055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18057                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18058                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18059                 }
18060                 if (r->user) {
18061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18062                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18064                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18065                 }
18066         }
18067         return NDR_ERR_SUCCESS;
18068 }
18069
18070 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
18071 {
18072         uint32_t _ptr_client;
18073         TALLOC_CTX *_mem_save_client_0;
18074         uint32_t _ptr_user;
18075         TALLOC_CTX *_mem_save_user_0;
18076         if (ndr_flags & NDR_SCALARS) {
18077                 NDR_CHECK(ndr_pull_align(ndr, 4));
18078                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18079                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18080                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
18081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18082                 if (_ptr_client) {
18083                         NDR_PULL_ALLOC(ndr, r->client);
18084                 } else {
18085                         r->client = NULL;
18086                 }
18087                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18088                 if (_ptr_user) {
18089                         NDR_PULL_ALLOC(ndr, r->user);
18090                 } else {
18091                         r->user = NULL;
18092                 }
18093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18094                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18095                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18096                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18097                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
18098         }
18099         if (ndr_flags & NDR_BUFFERS) {
18100                 if (r->client) {
18101                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18102                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18103                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18104                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18105                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18106                                 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));
18107                         }
18108                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18109                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18110                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18111                 }
18112                 if (r->user) {
18113                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18114                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18115                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18116                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18117                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18118                                 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));
18119                         }
18120                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18121                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18122                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18123                 }
18124         }
18125         return NDR_ERR_SUCCESS;
18126 }
18127
18128 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
18129 {
18130         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
18131         ndr->depth++;
18132         ndr_print_uint32(ndr, "size", r->size);
18133         ndr_print_uint32(ndr, "flags", r->flags);
18134         ndr_print_uint32(ndr, "size2", r->size2);
18135         ndr_print_ptr(ndr, "client", r->client);
18136         ndr->depth++;
18137         if (r->client) {
18138                 ndr_print_string(ndr, "client", r->client);
18139         }
18140         ndr->depth--;
18141         ndr_print_ptr(ndr, "user", r->user);
18142         ndr->depth++;
18143         if (r->user) {
18144                 ndr_print_string(ndr, "user", r->user);
18145         }
18146         ndr->depth--;
18147         ndr_print_uint32(ndr, "build", r->build);
18148         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18149         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18150         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18151         ndr_print_udlong(ndr, "reserved", r->reserved);
18152         ndr->depth--;
18153 }
18154
18155 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18156 {
18157         if (ndr_flags & NDR_SCALARS) {
18158                 int level = ndr_push_get_switch_value(ndr, r);
18159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18160                 switch (level) {
18161                         case 1: {
18162                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18163                         break; }
18164
18165                         case 2: {
18166                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18167                         break; }
18168
18169                         case 3: {
18170                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18171                         break; }
18172
18173                         default:
18174                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18175                 }
18176         }
18177         if (ndr_flags & NDR_BUFFERS) {
18178                 int level = ndr_push_get_switch_value(ndr, r);
18179                 switch (level) {
18180                         case 1:
18181                                 if (r->level1) {
18182                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18183                                 }
18184                         break;
18185
18186                         case 2:
18187                                 if (r->level2) {
18188                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18189                                 }
18190                         break;
18191
18192                         case 3:
18193                                 if (r->level3) {
18194                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18195                                 }
18196                         break;
18197
18198                         default:
18199                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18200                 }
18201         }
18202         return NDR_ERR_SUCCESS;
18203 }
18204
18205 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18206 {
18207         int level;
18208         uint32_t _level;
18209         TALLOC_CTX *_mem_save_level1_0;
18210         TALLOC_CTX *_mem_save_level2_0;
18211         TALLOC_CTX *_mem_save_level3_0;
18212         level = ndr_pull_get_switch_value(ndr, r);
18213         if (ndr_flags & NDR_SCALARS) {
18214                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18215                 if (_level != level) {
18216                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18217                 }
18218                 switch (level) {
18219                         case 1: {
18220                                 uint32_t _ptr_level1;
18221                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18222                                 if (_ptr_level1) {
18223                                         NDR_PULL_ALLOC(ndr, r->level1);
18224                                 } else {
18225                                         r->level1 = NULL;
18226                                 }
18227                         break; }
18228
18229                         case 2: {
18230                                 uint32_t _ptr_level2;
18231                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18232                                 if (_ptr_level2) {
18233                                         NDR_PULL_ALLOC(ndr, r->level2);
18234                                 } else {
18235                                         r->level2 = NULL;
18236                                 }
18237                         break; }
18238
18239                         case 3: {
18240                                 uint32_t _ptr_level3;
18241                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18242                                 if (_ptr_level3) {
18243                                         NDR_PULL_ALLOC(ndr, r->level3);
18244                                 } else {
18245                                         r->level3 = NULL;
18246                                 }
18247                         break; }
18248
18249                         default:
18250                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18251                 }
18252         }
18253         if (ndr_flags & NDR_BUFFERS) {
18254                 switch (level) {
18255                         case 1:
18256                                 if (r->level1) {
18257                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18258                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18259                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18260                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18261                                 }
18262                         break;
18263
18264                         case 2:
18265                                 if (r->level2) {
18266                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18267                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18268                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18269                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18270                                 }
18271                         break;
18272
18273                         case 3:
18274                                 if (r->level3) {
18275                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18276                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18277                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18278                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18279                                 }
18280                         break;
18281
18282                         default:
18283                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18284                 }
18285         }
18286         return NDR_ERR_SUCCESS;
18287 }
18288
18289 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18290 {
18291         int level;
18292         level = ndr_print_get_switch_value(ndr, r);
18293         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18294         switch (level) {
18295                 case 1:
18296                         ndr_print_ptr(ndr, "level1", r->level1);
18297                         ndr->depth++;
18298                         if (r->level1) {
18299                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18300                         }
18301                         ndr->depth--;
18302                 break;
18303
18304                 case 2:
18305                         ndr_print_ptr(ndr, "level2", r->level2);
18306                         ndr->depth++;
18307                         if (r->level2) {
18308                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18309                         }
18310                         ndr->depth--;
18311                 break;
18312
18313                 case 3:
18314                         ndr_print_ptr(ndr, "level3", r->level3);
18315                         ndr->depth++;
18316                         if (r->level3) {
18317                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18318                         }
18319                         ndr->depth--;
18320                 break;
18321
18322                 default:
18323                         ndr_print_bad_level(ndr, name, level);
18324         }
18325 }
18326
18327 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18328 {
18329         if (ndr_flags & NDR_SCALARS) {
18330                 NDR_CHECK(ndr_push_align(ndr, 4));
18331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18332                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18333                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18334         }
18335         if (ndr_flags & NDR_BUFFERS) {
18336                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18337         }
18338         return NDR_ERR_SUCCESS;
18339 }
18340
18341 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18342 {
18343         if (ndr_flags & NDR_SCALARS) {
18344                 NDR_CHECK(ndr_pull_align(ndr, 4));
18345                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18346                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18347                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18348         }
18349         if (ndr_flags & NDR_BUFFERS) {
18350                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18351         }
18352         return NDR_ERR_SUCCESS;
18353 }
18354
18355 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18356 {
18357         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18358         ndr->depth++;
18359         ndr_print_uint32(ndr, "level", r->level);
18360         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18361         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18362         ndr->depth--;
18363 }
18364
18365 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18366 {
18367         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18368         return NDR_ERR_SUCCESS;
18369 }
18370
18371 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18372 {
18373         uint32_t v;
18374         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18375         *r = v;
18376         return NDR_ERR_SUCCESS;
18377 }
18378
18379 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18380 {
18381         ndr_print_uint32(ndr, name, r);
18382         ndr->depth++;
18383         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18384         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18385         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18386         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18387         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18388         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18389         ndr->depth--;
18390 }
18391
18392 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
18393 {
18394         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18395         if (ndr_flags & NDR_SCALARS) {
18396                 NDR_CHECK(ndr_push_align(ndr, 4));
18397                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18398                 {
18399                         uint32_t _flags_save_string = ndr->flags;
18400                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18401                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
18402                         ndr->flags = _flags_save_string;
18403                 }
18404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
18405                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
18406                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
18407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
18408         }
18409         if (ndr_flags & NDR_BUFFERS) {
18410                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18411                 {
18412                         uint32_t _flags_save_string = ndr->flags;
18413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18414                         if (r->value_name) {
18415                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
18416                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
18417                         }
18418                         ndr->flags = _flags_save_string;
18419                 }
18420                 if (r->data) {
18421                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
18422                         {
18423                                 struct ndr_push *_ndr_data;
18424                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18425                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
18426                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18427                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18428                         }
18429                 }
18430         }
18431         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18432         return NDR_ERR_SUCCESS;
18433 }
18434
18435 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
18436 {
18437         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18438         uint32_t _ptr_value_name;
18439         TALLOC_CTX *_mem_save_value_name_0;
18440         uint32_t _ptr_data;
18441         TALLOC_CTX *_mem_save_data_0;
18442         if (ndr_flags & NDR_SCALARS) {
18443                 NDR_CHECK(ndr_pull_align(ndr, 4));
18444                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18445                 {
18446                         uint32_t _flags_save_string = ndr->flags;
18447                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18448                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
18449                         if (_ptr_value_name) {
18450                                 NDR_PULL_ALLOC(ndr, r->value_name);
18451                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
18452                         } else {
18453                                 r->value_name = NULL;
18454                         }
18455                         ndr->flags = _flags_save_string;
18456                 }
18457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
18458                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
18459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
18460                 if (_ptr_data) {
18461                         NDR_PULL_ALLOC(ndr, r->data);
18462                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
18463                 } else {
18464                         r->data = NULL;
18465                 }
18466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
18467         }
18468         if (ndr_flags & NDR_BUFFERS) {
18469                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18470                 {
18471                         uint32_t _flags_save_string = ndr->flags;
18472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18473                         if (r->value_name) {
18474                                 uint32_t _relative_save_offset;
18475                                 _relative_save_offset = ndr->offset;
18476                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
18477                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18478                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
18479                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
18480                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
18481                                 ndr->offset = _relative_save_offset;
18482                         }
18483                         ndr->flags = _flags_save_string;
18484                 }
18485                 if (r->data) {
18486                         uint32_t _relative_save_offset;
18487                         _relative_save_offset = ndr->offset;
18488                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
18489                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
18490                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
18491                         {
18492                                 struct ndr_pull *_ndr_data;
18493                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18494                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
18495                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18496                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18497                         }
18498                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
18499                         ndr->offset = _relative_save_offset;
18500                 }
18501         }
18502         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18503         return NDR_ERR_SUCCESS;
18504 }
18505
18506 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
18507 {
18508         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
18509         ndr->depth++;
18510         ndr_print_ptr(ndr, "value_name", r->value_name);
18511         ndr->depth++;
18512         if (r->value_name) {
18513                 ndr_print_string(ndr, "value_name", r->value_name);
18514         }
18515         ndr->depth--;
18516         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
18517         ndr_print_winreg_Type(ndr, "type", r->type);
18518         ndr_print_ptr(ndr, "data", r->data);
18519         ndr->depth++;
18520         if (r->data) {
18521                 ndr_print_set_switch_value(ndr, r->data, r->type);
18522                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
18523         }
18524         ndr->depth--;
18525         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);
18526         ndr->depth--;
18527 }
18528
18529 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
18530 {
18531         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
18532 }
18533
18534 static enum ndr_err_code ndr_push_spoolss_KeyNames(struct ndr_push *ndr, int ndr_flags, const union spoolss_KeyNames *r)
18535 {
18536         if (ndr_flags & NDR_SCALARS) {
18537                 int level = ndr_push_get_switch_value(ndr, r);
18538                 switch (level) {
18539                         case 0: {
18540                         break; }
18541
18542                         case 1: {
18543                         break; }
18544
18545                         default: {
18546                                 {
18547                                         uint32_t _flags_save_string_array = ndr->flags;
18548                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18549                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
18550                                         ndr->flags = _flags_save_string_array;
18551                                 }
18552                         break; }
18553
18554                 }
18555         }
18556         if (ndr_flags & NDR_BUFFERS) {
18557                 int level = ndr_push_get_switch_value(ndr, r);
18558                 switch (level) {
18559                         case 0:
18560                         break;
18561
18562                         case 1:
18563                         break;
18564
18565                         default:
18566                         break;
18567
18568                 }
18569         }
18570         return NDR_ERR_SUCCESS;
18571 }
18572
18573 static enum ndr_err_code ndr_pull_spoolss_KeyNames(struct ndr_pull *ndr, int ndr_flags, union spoolss_KeyNames *r)
18574 {
18575         int level;
18576         level = ndr_pull_get_switch_value(ndr, r);
18577         if (ndr_flags & NDR_SCALARS) {
18578                 switch (level) {
18579                         case 0: {
18580                         break; }
18581
18582                         case 1: {
18583                         break; }
18584
18585                         default: {
18586                                 {
18587                                         uint32_t _flags_save_string_array = ndr->flags;
18588                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18589                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
18590                                         ndr->flags = _flags_save_string_array;
18591                                 }
18592                         break; }
18593
18594                 }
18595         }
18596         if (ndr_flags & NDR_BUFFERS) {
18597                 switch (level) {
18598                         case 0:
18599                         break;
18600
18601                         case 1:
18602                         break;
18603
18604                         default:
18605                         break;
18606
18607                 }
18608         }
18609         return NDR_ERR_SUCCESS;
18610 }
18611
18612 _PUBLIC_ void ndr_print_spoolss_KeyNames(struct ndr_print *ndr, const char *name, const union spoolss_KeyNames *r)
18613 {
18614         int level;
18615         level = ndr_print_get_switch_value(ndr, r);
18616         ndr_print_union(ndr, name, level, "spoolss_KeyNames");
18617         switch (level) {
18618                 case 0:
18619                 break;
18620
18621                 case 1:
18622                 break;
18623
18624                 default:
18625                         ndr_print_string_array(ndr, "string_array", r->string_array);
18626                 break;
18627
18628         }
18629 }
18630
18631 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18632 {
18633         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18634         return NDR_ERR_SUCCESS;
18635 }
18636
18637 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18638 {
18639         uint32_t v;
18640         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18641         *r = v;
18642         return NDR_ERR_SUCCESS;
18643 }
18644
18645 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18646 {
18647         ndr_print_uint32(ndr, name, r);
18648         ndr->depth++;
18649         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18650         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18651         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18652         ndr->depth--;
18653 }
18654
18655 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18656 {
18657         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18658         return NDR_ERR_SUCCESS;
18659 }
18660
18661 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18662 {
18663         uint32_t v;
18664         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18665         *r = v;
18666         return NDR_ERR_SUCCESS;
18667 }
18668
18669 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18670 {
18671         const char *val = NULL;
18672
18673         switch (r) {
18674                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18675                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18676         }
18677         ndr_print_enum(ndr, name, "ENUM", val, r);
18678 }
18679
18680 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18681 {
18682         if (ndr_flags & NDR_SCALARS) {
18683                 NDR_CHECK(ndr_push_align(ndr, 4));
18684                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18686                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18689                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18690                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18692                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18693                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18694                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18695                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18696                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18697                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18699         }
18700         if (ndr_flags & NDR_BUFFERS) {
18701         }
18702         return NDR_ERR_SUCCESS;
18703 }
18704
18705 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18706 {
18707         if (ndr_flags & NDR_SCALARS) {
18708                 NDR_CHECK(ndr_pull_align(ndr, 4));
18709                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18710                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18711                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18712                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18713                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18714                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18715                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18716                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18717                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18718                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18719                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18720                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18723                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18724         }
18725         if (ndr_flags & NDR_BUFFERS) {
18726         }
18727         return NDR_ERR_SUCCESS;
18728 }
18729
18730 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18731 {
18732         ndr_print_struct(ndr, name, "spoolss_PortData1");
18733         ndr->depth++;
18734         ndr_print_string(ndr, "portname", r->portname);
18735         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18736         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18737         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18738         ndr_print_uint32(ndr, "reserved", r->reserved);
18739         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18740         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18741         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18742         ndr_print_string(ndr, "queue", r->queue);
18743         ndr_print_string(ndr, "ip_address", r->ip_address);
18744         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18745         ndr_print_string(ndr, "device_type", r->device_type);
18746         ndr_print_uint32(ndr, "port_number", r->port_number);
18747         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18748         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18749         ndr->depth--;
18750 }
18751
18752 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18753 {
18754         if (ndr_flags & NDR_SCALARS) {
18755                 NDR_CHECK(ndr_push_align(ndr, 4));
18756                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18758                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18761                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18762                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18764                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18765                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18769                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18770         }
18771         if (ndr_flags & NDR_BUFFERS) {
18772         }
18773         return NDR_ERR_SUCCESS;
18774 }
18775
18776 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18777 {
18778         if (ndr_flags & NDR_SCALARS) {
18779                 NDR_CHECK(ndr_pull_align(ndr, 4));
18780                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18781                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18782                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18783                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18784                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18785                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18786                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18787                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18788                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18789                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18790                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18791                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18794         }
18795         if (ndr_flags & NDR_BUFFERS) {
18796         }
18797         return NDR_ERR_SUCCESS;
18798 }
18799
18800 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18801 {
18802         ndr_print_struct(ndr, name, "spoolss_PortData2");
18803         ndr->depth++;
18804         ndr_print_string(ndr, "portname", r->portname);
18805         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18806         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18807         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18808         ndr_print_uint32(ndr, "reserved", r->reserved);
18809         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18810         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18811         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18812         ndr_print_string(ndr, "queue", r->queue);
18813         ndr_print_string(ndr, "device_type", r->device_type);
18814         ndr_print_uint32(ndr, "port_number", r->port_number);
18815         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18816         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18817         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18818         ndr->depth--;
18819 }
18820
18821 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18822 {
18823         if (ndr_flags & NDR_SCALARS) {
18824                 NDR_CHECK(ndr_push_align(ndr, 4));
18825                 {
18826                         uint32_t _flags_save_string = ndr->flags;
18827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18828                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18829                         ndr->flags = _flags_save_string;
18830                 }
18831         }
18832         if (ndr_flags & NDR_BUFFERS) {
18833         }
18834         return NDR_ERR_SUCCESS;
18835 }
18836
18837 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18838 {
18839         if (ndr_flags & NDR_SCALARS) {
18840                 NDR_CHECK(ndr_pull_align(ndr, 4));
18841                 {
18842                         uint32_t _flags_save_string = ndr->flags;
18843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18844                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18845                         ndr->flags = _flags_save_string;
18846                 }
18847         }
18848         if (ndr_flags & NDR_BUFFERS) {
18849         }
18850         return NDR_ERR_SUCCESS;
18851 }
18852
18853 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18854 {
18855         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18856         ndr->depth++;
18857         ndr_print_string(ndr, "dll_name", r->dll_name);
18858         ndr->depth--;
18859 }
18860
18861 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18862 {
18863         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18864         return NDR_ERR_SUCCESS;
18865 }
18866
18867 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18868 {
18869         uint32_t v;
18870         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18871         *r = v;
18872         return NDR_ERR_SUCCESS;
18873 }
18874
18875 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18876 {
18877         ndr_print_uint32(ndr, name, r);
18878         ndr->depth++;
18879         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18880         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18881         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18882         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18883         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18884         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18887         ndr->depth--;
18888 }
18889
18890 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18891 {
18892         if (flags & NDR_IN) {
18893                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18895                 if (r->in.server) {
18896                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18899                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18900                 }
18901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18903                 if (r->in.buffer) {
18904                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18905                 }
18906                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18907         }
18908         if (flags & NDR_OUT) {
18909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18910                 if (r->out.info) {
18911                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18912                 }
18913                 if (r->out.needed == NULL) {
18914                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18915                 }
18916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18917                 if (r->out.count == NULL) {
18918                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18919                 }
18920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18921                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18922         }
18923         return NDR_ERR_SUCCESS;
18924 }
18925
18926 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18927 {
18928         uint32_t _ptr_server;
18929         uint32_t _ptr_buffer;
18930         uint32_t _ptr_info;
18931         TALLOC_CTX *_mem_save_server_0;
18932         TALLOC_CTX *_mem_save_buffer_0;
18933         TALLOC_CTX *_mem_save_info_0;
18934         TALLOC_CTX *_mem_save_needed_0;
18935         TALLOC_CTX *_mem_save_count_0;
18936         if (flags & NDR_IN) {
18937                 ZERO_STRUCT(r->out);
18938
18939                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18940                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18941                 if (_ptr_server) {
18942                         NDR_PULL_ALLOC(ndr, r->in.server);
18943                 } else {
18944                         r->in.server = NULL;
18945                 }
18946                 if (r->in.server) {
18947                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18948                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18949                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18950                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18951                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18952                                 return 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));
18953                         }
18954                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18955                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18956                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18957                 }
18958                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18959                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18960                 if (_ptr_buffer) {
18961                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18962                 } else {
18963                         r->in.buffer = NULL;
18964                 }
18965                 if (r->in.buffer) {
18966                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18967                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18968                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18970                 }
18971                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18972                 NDR_PULL_ALLOC(ndr, r->out.needed);
18973                 ZERO_STRUCTP(r->out.needed);
18974                 NDR_PULL_ALLOC(ndr, r->out.count);
18975                 ZERO_STRUCTP(r->out.count);
18976         }
18977         if (flags & NDR_OUT) {
18978                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18979                 if (_ptr_info) {
18980                         NDR_PULL_ALLOC(ndr, r->out.info);
18981                 } else {
18982                         r->out.info = NULL;
18983                 }
18984                 if (r->out.info) {
18985                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18986                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18987                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18989                 }
18990                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18991                         NDR_PULL_ALLOC(ndr, r->out.needed);
18992                 }
18993                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18994                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18996                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18998                         NDR_PULL_ALLOC(ndr, r->out.count);
18999                 }
19000                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19001                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19002                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19004                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19005         }
19006         return NDR_ERR_SUCCESS;
19007 }
19008
19009 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
19010 {
19011         uint32_t cntr_info_0;
19012         if (flags & NDR_IN) {
19013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19015         }
19016         if (flags & NDR_OUT) {
19017                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19018                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19019                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19020                 }
19021                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19022                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19023                 }
19024         }
19025         return NDR_ERR_SUCCESS;
19026 }
19027
19028 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
19029 {
19030         uint32_t cntr_info_0;
19031         TALLOC_CTX *_mem_save_info_0;
19032         if (flags & NDR_IN) {
19033                 ZERO_STRUCT(r->out);
19034
19035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19037         }
19038         if (flags & NDR_OUT) {
19039                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19040                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19041                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19042                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19043                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19044                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19045                 }
19046                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19047                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19048                 }
19049                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19050         }
19051         return NDR_ERR_SUCCESS;
19052 }
19053
19054 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
19055 {
19056         uint32_t cntr_info_2;
19057         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
19058         ndr->depth++;
19059         if (flags & NDR_SET_VALUES) {
19060                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19061         }
19062         if (flags & NDR_IN) {
19063                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
19064                 ndr->depth++;
19065                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
19066                 ndr_print_ptr(ndr, "server", r->in.server);
19067                 ndr->depth++;
19068                 if (r->in.server) {
19069                         ndr_print_string(ndr, "server", r->in.server);
19070                 }
19071                 ndr->depth--;
19072                 ndr_print_uint32(ndr, "level", r->in.level);
19073                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19074                 ndr->depth++;
19075                 if (r->in.buffer) {
19076                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19077                 }
19078                 ndr->depth--;
19079                 ndr_print_uint32(ndr, "offered", r->in.offered);
19080                 ndr->depth--;
19081         }
19082         if (flags & NDR_OUT) {
19083                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
19084                 ndr->depth++;
19085                 ndr_print_ptr(ndr, "count", r->out.count);
19086                 ndr->depth++;
19087                 ndr_print_uint32(ndr, "count", *r->out.count);
19088                 ndr->depth--;
19089                 ndr_print_ptr(ndr, "info", r->out.info);
19090                 ndr->depth++;
19091                 ndr_print_ptr(ndr, "info", *r->out.info);
19092                 ndr->depth++;
19093                 if (*r->out.info) {
19094                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19095                         ndr->depth++;
19096                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19097                                 char *idx_2=NULL;
19098                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19099                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19100                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19101                                         free(idx_2);
19102                                 }
19103                         }
19104                         ndr->depth--;
19105                 }
19106                 ndr->depth--;
19107                 ndr->depth--;
19108                 ndr_print_ptr(ndr, "needed", r->out.needed);
19109                 ndr->depth++;
19110                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19111                 ndr->depth--;
19112                 ndr_print_WERROR(ndr, "result", r->out.result);
19113                 ndr->depth--;
19114         }
19115         ndr->depth--;
19116 }
19117
19118 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
19119 {
19120         if (flags & NDR_IN) {
19121                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
19122                 if (r->in.printername) {
19123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19127                 }
19128                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
19129                 if (r->in.datatype) {
19130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19132                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19133                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19134                 }
19135                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19136                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
19137         }
19138         if (flags & NDR_OUT) {
19139                 if (r->out.handle == NULL) {
19140                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19141                 }
19142                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19143                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19144         }
19145         return NDR_ERR_SUCCESS;
19146 }
19147
19148 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
19149 {
19150         uint32_t _ptr_printername;
19151         uint32_t _ptr_datatype;
19152         TALLOC_CTX *_mem_save_printername_0;
19153         TALLOC_CTX *_mem_save_datatype_0;
19154         TALLOC_CTX *_mem_save_handle_0;
19155         if (flags & NDR_IN) {
19156                 ZERO_STRUCT(r->out);
19157
19158                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
19159                 if (_ptr_printername) {
19160                         NDR_PULL_ALLOC(ndr, r->in.printername);
19161                 } else {
19162                         r->in.printername = NULL;
19163                 }
19164                 if (r->in.printername) {
19165                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19166                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
19167                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
19168                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
19169                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
19170                                 return 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));
19171                         }
19172                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
19173                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
19174                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
19175                 }
19176                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
19177                 if (_ptr_datatype) {
19178                         NDR_PULL_ALLOC(ndr, r->in.datatype);
19179                 } else {
19180                         r->in.datatype = NULL;
19181                 }
19182                 if (r->in.datatype) {
19183                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
19184                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
19185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
19186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
19187                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
19188                                 return 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));
19189                         }
19190                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
19191                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
19192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
19193                 }
19194                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19195                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
19196                 NDR_PULL_ALLOC(ndr, r->out.handle);
19197                 ZERO_STRUCTP(r->out.handle);
19198         }
19199         if (flags & NDR_OUT) {
19200                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19201                         NDR_PULL_ALLOC(ndr, r->out.handle);
19202                 }
19203                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19204                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19205                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19206                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19207                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19208         }
19209         return NDR_ERR_SUCCESS;
19210 }
19211
19212 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
19213 {
19214         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
19215         ndr->depth++;
19216         if (flags & NDR_SET_VALUES) {
19217                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19218         }
19219         if (flags & NDR_IN) {
19220                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
19221                 ndr->depth++;
19222                 ndr_print_ptr(ndr, "printername", r->in.printername);
19223                 ndr->depth++;
19224                 if (r->in.printername) {
19225                         ndr_print_string(ndr, "printername", r->in.printername);
19226                 }
19227                 ndr->depth--;
19228                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
19229                 ndr->depth++;
19230                 if (r->in.datatype) {
19231                         ndr_print_string(ndr, "datatype", r->in.datatype);
19232                 }
19233                 ndr->depth--;
19234                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
19235                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
19236                 ndr->depth--;
19237         }
19238         if (flags & NDR_OUT) {
19239                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
19240                 ndr->depth++;
19241                 ndr_print_ptr(ndr, "handle", r->out.handle);
19242                 ndr->depth++;
19243                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19244                 ndr->depth--;
19245                 ndr_print_WERROR(ndr, "result", r->out.result);
19246                 ndr->depth--;
19247         }
19248         ndr->depth--;
19249 }
19250
19251 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
19252 {
19253         if (flags & NDR_IN) {
19254                 if (r->in.handle == NULL) {
19255                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19256                 }
19257                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19259                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19260                 if (r->in.ctr) {
19261                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19262                 }
19263                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19264         }
19265         if (flags & NDR_OUT) {
19266                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19267         }
19268         return NDR_ERR_SUCCESS;
19269 }
19270
19271 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19272 {
19273         uint32_t _ptr_ctr;
19274         TALLOC_CTX *_mem_save_handle_0;
19275         TALLOC_CTX *_mem_save_ctr_0;
19276         if (flags & NDR_IN) {
19277                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19278                         NDR_PULL_ALLOC(ndr, r->in.handle);
19279                 }
19280                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19281                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19282                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19284                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19285                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19286                 if (_ptr_ctr) {
19287                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19288                 } else {
19289                         r->in.ctr = NULL;
19290                 }
19291                 if (r->in.ctr) {
19292                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19293                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
19294                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19295                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
19296                 }
19297                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
19298         }
19299         if (flags & NDR_OUT) {
19300                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19301         }
19302         return NDR_ERR_SUCCESS;
19303 }
19304
19305 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
19306 {
19307         ndr_print_struct(ndr, name, "spoolss_SetJob");
19308         ndr->depth++;
19309         if (flags & NDR_SET_VALUES) {
19310                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19311         }
19312         if (flags & NDR_IN) {
19313                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
19314                 ndr->depth++;
19315                 ndr_print_ptr(ndr, "handle", r->in.handle);
19316                 ndr->depth++;
19317                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19318                 ndr->depth--;
19319                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19320                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
19321                 ndr->depth++;
19322                 if (r->in.ctr) {
19323                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
19324                 }
19325                 ndr->depth--;
19326                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
19327                 ndr->depth--;
19328         }
19329         if (flags & NDR_OUT) {
19330                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
19331                 ndr->depth++;
19332                 ndr_print_WERROR(ndr, "result", r->out.result);
19333                 ndr->depth--;
19334         }
19335         ndr->depth--;
19336 }
19337
19338 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
19339 {
19340         if (flags & NDR_IN) {
19341                 if (r->in.handle == NULL) {
19342                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19343                 }
19344                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19346                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19347                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19348                 if (r->in.buffer) {
19349                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19350                 }
19351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19352         }
19353         if (flags & NDR_OUT) {
19354                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19355                 if (r->out.info) {
19356                         {
19357                                 struct ndr_push *_ndr_info;
19358                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19359                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19360                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19361                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19362                         }
19363                 }
19364                 if (r->out.needed == NULL) {
19365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19366                 }
19367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19368                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19369         }
19370         return NDR_ERR_SUCCESS;
19371 }
19372
19373 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
19374 {
19375         uint32_t _ptr_buffer;
19376         uint32_t _ptr_info;
19377         TALLOC_CTX *_mem_save_handle_0;
19378         TALLOC_CTX *_mem_save_buffer_0;
19379         TALLOC_CTX *_mem_save_info_0;
19380         TALLOC_CTX *_mem_save_needed_0;
19381         if (flags & NDR_IN) {
19382                 ZERO_STRUCT(r->out);
19383
19384                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19385                         NDR_PULL_ALLOC(ndr, r->in.handle);
19386                 }
19387                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19388                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19389                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19390                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19391                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19392                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19393                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19394                 if (_ptr_buffer) {
19395                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19396                 } else {
19397                         r->in.buffer = NULL;
19398                 }
19399                 if (r->in.buffer) {
19400                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19401                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19402                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19404                 }
19405                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19406                 NDR_PULL_ALLOC(ndr, r->out.needed);
19407                 ZERO_STRUCTP(r->out.needed);
19408         }
19409         if (flags & NDR_OUT) {
19410                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19411                 if (_ptr_info) {
19412                         NDR_PULL_ALLOC(ndr, r->out.info);
19413                 } else {
19414                         r->out.info = NULL;
19415                 }
19416                 if (r->out.info) {
19417                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19418                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19419                         {
19420                                 struct ndr_pull *_ndr_info;
19421                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19422                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19423                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19424                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19425                         }
19426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19427                 }
19428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19429                         NDR_PULL_ALLOC(ndr, r->out.needed);
19430                 }
19431                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19432                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19435                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19436         }
19437         return NDR_ERR_SUCCESS;
19438 }
19439
19440 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19441 {
19442         ndr_print_struct(ndr, name, "spoolss_GetJob");
19443         ndr->depth++;
19444         if (flags & NDR_SET_VALUES) {
19445                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19446         }
19447         if (flags & NDR_IN) {
19448                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19449                 ndr->depth++;
19450                 ndr_print_ptr(ndr, "handle", r->in.handle);
19451                 ndr->depth++;
19452                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19453                 ndr->depth--;
19454                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19455                 ndr_print_uint32(ndr, "level", r->in.level);
19456                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19457                 ndr->depth++;
19458                 if (r->in.buffer) {
19459                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19460                 }
19461                 ndr->depth--;
19462                 ndr_print_uint32(ndr, "offered", r->in.offered);
19463                 ndr->depth--;
19464         }
19465         if (flags & NDR_OUT) {
19466                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19467                 ndr->depth++;
19468                 ndr_print_ptr(ndr, "info", r->out.info);
19469                 ndr->depth++;
19470                 if (r->out.info) {
19471                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19472                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19473                 }
19474                 ndr->depth--;
19475                 ndr_print_ptr(ndr, "needed", r->out.needed);
19476                 ndr->depth++;
19477                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19478                 ndr->depth--;
19479                 ndr_print_WERROR(ndr, "result", r->out.result);
19480                 ndr->depth--;
19481         }
19482         ndr->depth--;
19483 }
19484
19485 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19486 {
19487         if (flags & NDR_IN) {
19488                 if (r->in.handle == NULL) {
19489                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19490                 }
19491                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19492                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19493                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19494                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19495                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19496                 if (r->in.buffer) {
19497                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19498                 }
19499                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19500         }
19501         if (flags & NDR_OUT) {
19502                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19503                 if (r->out.info) {
19504                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19505                 }
19506                 if (r->out.needed == NULL) {
19507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19508                 }
19509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19510                 if (r->out.count == NULL) {
19511                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19512                 }
19513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19514                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19515         }
19516         return NDR_ERR_SUCCESS;
19517 }
19518
19519 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19520 {
19521         uint32_t _ptr_buffer;
19522         uint32_t _ptr_info;
19523         TALLOC_CTX *_mem_save_handle_0;
19524         TALLOC_CTX *_mem_save_buffer_0;
19525         TALLOC_CTX *_mem_save_info_0;
19526         TALLOC_CTX *_mem_save_needed_0;
19527         TALLOC_CTX *_mem_save_count_0;
19528         if (flags & NDR_IN) {
19529                 ZERO_STRUCT(r->out);
19530
19531                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19532                         NDR_PULL_ALLOC(ndr, r->in.handle);
19533                 }
19534                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19535                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19536                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19537                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19540                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19541                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19542                 if (_ptr_buffer) {
19543                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19544                 } else {
19545                         r->in.buffer = NULL;
19546                 }
19547                 if (r->in.buffer) {
19548                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19549                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19550                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19551                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19552                 }
19553                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19554                 NDR_PULL_ALLOC(ndr, r->out.needed);
19555                 ZERO_STRUCTP(r->out.needed);
19556                 NDR_PULL_ALLOC(ndr, r->out.count);
19557                 ZERO_STRUCTP(r->out.count);
19558         }
19559         if (flags & NDR_OUT) {
19560                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19561                 if (_ptr_info) {
19562                         NDR_PULL_ALLOC(ndr, r->out.info);
19563                 } else {
19564                         r->out.info = NULL;
19565                 }
19566                 if (r->out.info) {
19567                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19568                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19569                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19571                 }
19572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19573                         NDR_PULL_ALLOC(ndr, r->out.needed);
19574                 }
19575                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19576                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19577                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19578                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19579                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19580                         NDR_PULL_ALLOC(ndr, r->out.count);
19581                 }
19582                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19583                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19584                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19585                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19586                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19587         }
19588         return NDR_ERR_SUCCESS;
19589 }
19590
19591 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19592 {
19593         uint32_t cntr_info_0;
19594         if (flags & NDR_IN) {
19595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19597         }
19598         if (flags & NDR_OUT) {
19599                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19600                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19601                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19602                 }
19603                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19604                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19605                 }
19606         }
19607         return NDR_ERR_SUCCESS;
19608 }
19609
19610 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19611 {
19612         uint32_t cntr_info_0;
19613         TALLOC_CTX *_mem_save_info_0;
19614         if (flags & NDR_IN) {
19615                 ZERO_STRUCT(r->out);
19616
19617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19619         }
19620         if (flags & NDR_OUT) {
19621                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19622                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19623                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19624                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19625                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19626                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19627                 }
19628                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19629                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19630                 }
19631                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19632         }
19633         return NDR_ERR_SUCCESS;
19634 }
19635
19636 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19637 {
19638         uint32_t cntr_info_2;
19639         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19640         ndr->depth++;
19641         if (flags & NDR_SET_VALUES) {
19642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19643         }
19644         if (flags & NDR_IN) {
19645                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19646                 ndr->depth++;
19647                 ndr_print_ptr(ndr, "handle", r->in.handle);
19648                 ndr->depth++;
19649                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19650                 ndr->depth--;
19651                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19652                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19653                 ndr_print_uint32(ndr, "level", r->in.level);
19654                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19655                 ndr->depth++;
19656                 if (r->in.buffer) {
19657                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19658                 }
19659                 ndr->depth--;
19660                 ndr_print_uint32(ndr, "offered", r->in.offered);
19661                 ndr->depth--;
19662         }
19663         if (flags & NDR_OUT) {
19664                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19665                 ndr->depth++;
19666                 ndr_print_ptr(ndr, "count", r->out.count);
19667                 ndr->depth++;
19668                 ndr_print_uint32(ndr, "count", *r->out.count);
19669                 ndr->depth--;
19670                 ndr_print_ptr(ndr, "info", r->out.info);
19671                 ndr->depth++;
19672                 ndr_print_ptr(ndr, "info", *r->out.info);
19673                 ndr->depth++;
19674                 if (*r->out.info) {
19675                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19676                         ndr->depth++;
19677                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19678                                 char *idx_2=NULL;
19679                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19680                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19681                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19682                                         free(idx_2);
19683                                 }
19684                         }
19685                         ndr->depth--;
19686                 }
19687                 ndr->depth--;
19688                 ndr->depth--;
19689                 ndr_print_ptr(ndr, "needed", r->out.needed);
19690                 ndr->depth++;
19691                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19692                 ndr->depth--;
19693                 ndr_print_WERROR(ndr, "result", r->out.result);
19694                 ndr->depth--;
19695         }
19696         ndr->depth--;
19697 }
19698
19699 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19700 {
19701         if (flags & NDR_IN) {
19702         }
19703         if (flags & NDR_OUT) {
19704                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19705         }
19706         return NDR_ERR_SUCCESS;
19707 }
19708
19709 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19710 {
19711         if (flags & NDR_IN) {
19712         }
19713         if (flags & NDR_OUT) {
19714                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19715         }
19716         return NDR_ERR_SUCCESS;
19717 }
19718
19719 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19720 {
19721         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19722         ndr->depth++;
19723         if (flags & NDR_SET_VALUES) {
19724                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19725         }
19726         if (flags & NDR_IN) {
19727                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19728                 ndr->depth++;
19729                 ndr->depth--;
19730         }
19731         if (flags & NDR_OUT) {
19732                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19733                 ndr->depth++;
19734                 ndr_print_WERROR(ndr, "result", r->out.result);
19735                 ndr->depth--;
19736         }
19737         ndr->depth--;
19738 }
19739
19740 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19741 {
19742         if (flags & NDR_IN) {
19743                 if (r->in.handle == NULL) {
19744                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19745                 }
19746                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19747         }
19748         if (flags & NDR_OUT) {
19749                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19750         }
19751         return NDR_ERR_SUCCESS;
19752 }
19753
19754 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19755 {
19756         TALLOC_CTX *_mem_save_handle_0;
19757         if (flags & NDR_IN) {
19758                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19759                         NDR_PULL_ALLOC(ndr, r->in.handle);
19760                 }
19761                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19762                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19763                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19764                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19765         }
19766         if (flags & NDR_OUT) {
19767                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19768         }
19769         return NDR_ERR_SUCCESS;
19770 }
19771
19772 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19773 {
19774         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19775         ndr->depth++;
19776         if (flags & NDR_SET_VALUES) {
19777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19778         }
19779         if (flags & NDR_IN) {
19780                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19781                 ndr->depth++;
19782                 ndr_print_ptr(ndr, "handle", r->in.handle);
19783                 ndr->depth++;
19784                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19785                 ndr->depth--;
19786                 ndr->depth--;
19787         }
19788         if (flags & NDR_OUT) {
19789                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19790                 ndr->depth++;
19791                 ndr_print_WERROR(ndr, "result", r->out.result);
19792                 ndr->depth--;
19793         }
19794         ndr->depth--;
19795 }
19796
19797 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19798 {
19799         if (flags & NDR_IN) {
19800                 if (r->in.handle == NULL) {
19801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19802                 }
19803                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19804                 if (r->in.info_ctr == NULL) {
19805                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19806                 }
19807                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19808                 if (r->in.devmode_ctr == NULL) {
19809                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19810                 }
19811                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19812                 if (r->in.secdesc_ctr == NULL) {
19813                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19814                 }
19815                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19816                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19817         }
19818         if (flags & NDR_OUT) {
19819                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19820         }
19821         return NDR_ERR_SUCCESS;
19822 }
19823
19824 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19825 {
19826         TALLOC_CTX *_mem_save_handle_0;
19827         TALLOC_CTX *_mem_save_info_ctr_0;
19828         TALLOC_CTX *_mem_save_devmode_ctr_0;
19829         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19830         if (flags & NDR_IN) {
19831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19832                         NDR_PULL_ALLOC(ndr, r->in.handle);
19833                 }
19834                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19835                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19836                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19838                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19839                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19840                 }
19841                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19842                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19843                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19844                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19845                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19846                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19847                 }
19848                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19849                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19850                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19851                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19853                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19854                 }
19855                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19856                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19857                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19859                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19860         }
19861         if (flags & NDR_OUT) {
19862                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19863         }
19864         return NDR_ERR_SUCCESS;
19865 }
19866
19867 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19868 {
19869         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19870         ndr->depth++;
19871         if (flags & NDR_SET_VALUES) {
19872                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19873         }
19874         if (flags & NDR_IN) {
19875                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19876                 ndr->depth++;
19877                 ndr_print_ptr(ndr, "handle", r->in.handle);
19878                 ndr->depth++;
19879                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19880                 ndr->depth--;
19881                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19882                 ndr->depth++;
19883                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19884                 ndr->depth--;
19885                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19886                 ndr->depth++;
19887                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19888                 ndr->depth--;
19889                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19890                 ndr->depth++;
19891                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19892                 ndr->depth--;
19893                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19894                 ndr->depth--;
19895         }
19896         if (flags & NDR_OUT) {
19897                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19898                 ndr->depth++;
19899                 ndr_print_WERROR(ndr, "result", r->out.result);
19900                 ndr->depth--;
19901         }
19902         ndr->depth--;
19903 }
19904
19905 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19906 {
19907         if (flags & NDR_IN) {
19908                 if (r->in.handle == NULL) {
19909                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19910                 }
19911                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19914                 if (r->in.buffer) {
19915                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19916                 }
19917                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19918         }
19919         if (flags & NDR_OUT) {
19920                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19921                 if (r->out.info) {
19922                         {
19923                                 struct ndr_push *_ndr_info;
19924                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19925                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19926                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19927                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19928                         }
19929                 }
19930                 if (r->out.needed == NULL) {
19931                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19932                 }
19933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19934                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19935         }
19936         return NDR_ERR_SUCCESS;
19937 }
19938
19939 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19940 {
19941         uint32_t _ptr_buffer;
19942         uint32_t _ptr_info;
19943         TALLOC_CTX *_mem_save_handle_0;
19944         TALLOC_CTX *_mem_save_buffer_0;
19945         TALLOC_CTX *_mem_save_info_0;
19946         TALLOC_CTX *_mem_save_needed_0;
19947         if (flags & NDR_IN) {
19948                 ZERO_STRUCT(r->out);
19949
19950                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19951                         NDR_PULL_ALLOC(ndr, r->in.handle);
19952                 }
19953                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19954                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19955                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19956                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19957                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19958                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19959                 if (_ptr_buffer) {
19960                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19961                 } else {
19962                         r->in.buffer = NULL;
19963                 }
19964                 if (r->in.buffer) {
19965                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19966                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19967                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19968                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19969                 }
19970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19971                 NDR_PULL_ALLOC(ndr, r->out.needed);
19972                 ZERO_STRUCTP(r->out.needed);
19973         }
19974         if (flags & NDR_OUT) {
19975                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19976                 if (_ptr_info) {
19977                         NDR_PULL_ALLOC(ndr, r->out.info);
19978                 } else {
19979                         r->out.info = NULL;
19980                 }
19981                 if (r->out.info) {
19982                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19983                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19984                         {
19985                                 struct ndr_pull *_ndr_info;
19986                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19987                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19988                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19989                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19990                         }
19991                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19992                 }
19993                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19994                         NDR_PULL_ALLOC(ndr, r->out.needed);
19995                 }
19996                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19997                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19998                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19999                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20000                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20001         }
20002         return NDR_ERR_SUCCESS;
20003 }
20004
20005 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
20006 {
20007         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
20008         ndr->depth++;
20009         if (flags & NDR_SET_VALUES) {
20010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20011         }
20012         if (flags & NDR_IN) {
20013                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
20014                 ndr->depth++;
20015                 ndr_print_ptr(ndr, "handle", r->in.handle);
20016                 ndr->depth++;
20017                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20018                 ndr->depth--;
20019                 ndr_print_uint32(ndr, "level", r->in.level);
20020                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20021                 ndr->depth++;
20022                 if (r->in.buffer) {
20023                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20024                 }
20025                 ndr->depth--;
20026                 ndr_print_uint32(ndr, "offered", r->in.offered);
20027                 ndr->depth--;
20028         }
20029         if (flags & NDR_OUT) {
20030                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
20031                 ndr->depth++;
20032                 ndr_print_ptr(ndr, "info", r->out.info);
20033                 ndr->depth++;
20034                 if (r->out.info) {
20035                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20036                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
20037                 }
20038                 ndr->depth--;
20039                 ndr_print_ptr(ndr, "needed", r->out.needed);
20040                 ndr->depth++;
20041                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20042                 ndr->depth--;
20043                 ndr_print_WERROR(ndr, "result", r->out.result);
20044                 ndr->depth--;
20045         }
20046         ndr->depth--;
20047 }
20048
20049 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
20050 {
20051         if (flags & NDR_IN) {
20052                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20053                 if (r->in.servername) {
20054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20056                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20057                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20058                 }
20059                 if (r->in.info_ctr == NULL) {
20060                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20061                 }
20062                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20063         }
20064         if (flags & NDR_OUT) {
20065                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20066         }
20067         return NDR_ERR_SUCCESS;
20068 }
20069
20070 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
20071 {
20072         uint32_t _ptr_servername;
20073         TALLOC_CTX *_mem_save_servername_0;
20074         TALLOC_CTX *_mem_save_info_ctr_0;
20075         if (flags & NDR_IN) {
20076                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20077                 if (_ptr_servername) {
20078                         NDR_PULL_ALLOC(ndr, r->in.servername);
20079                 } else {
20080                         r->in.servername = NULL;
20081                 }
20082                 if (r->in.servername) {
20083                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20084                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20085                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20086                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20087                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20088                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.servername), ndr_get_array_length(ndr, &r->in.servername));
20089                         }
20090                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20091                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20092                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20093                 }
20094                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20095                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
20096                 }
20097                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
20098                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
20099                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
20100                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
20101         }
20102         if (flags & NDR_OUT) {
20103                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20104         }
20105         return NDR_ERR_SUCCESS;
20106 }
20107
20108 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
20109 {
20110         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
20111         ndr->depth++;
20112         if (flags & NDR_SET_VALUES) {
20113                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20114         }
20115         if (flags & NDR_IN) {
20116                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
20117                 ndr->depth++;
20118                 ndr_print_ptr(ndr, "servername", r->in.servername);
20119                 ndr->depth++;
20120                 if (r->in.servername) {
20121                         ndr_print_string(ndr, "servername", r->in.servername);
20122                 }
20123                 ndr->depth--;
20124                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20125                 ndr->depth++;
20126                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20127                 ndr->depth--;
20128                 ndr->depth--;
20129         }
20130         if (flags & NDR_OUT) {
20131                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
20132                 ndr->depth++;
20133                 ndr_print_WERROR(ndr, "result", r->out.result);
20134                 ndr->depth--;
20135         }
20136         ndr->depth--;
20137 }
20138
20139 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
20140 {
20141         if (flags & NDR_IN) {
20142                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20143                 if (r->in.server) {
20144                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20147                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20148                 }
20149                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20150                 if (r->in.environment) {
20151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20154                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20155                 }
20156                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20157                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20158                 if (r->in.buffer) {
20159                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20160                 }
20161                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20162         }
20163         if (flags & NDR_OUT) {
20164                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20165                 if (r->out.info) {
20166                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20167                 }
20168                 if (r->out.needed == NULL) {
20169                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20170                 }
20171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20172                 if (r->out.count == NULL) {
20173                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20174                 }
20175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20176                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20177         }
20178         return NDR_ERR_SUCCESS;
20179 }
20180
20181 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
20182 {
20183         uint32_t _ptr_server;
20184         uint32_t _ptr_environment;
20185         uint32_t _ptr_buffer;
20186         uint32_t _ptr_info;
20187         TALLOC_CTX *_mem_save_server_0;
20188         TALLOC_CTX *_mem_save_environment_0;
20189         TALLOC_CTX *_mem_save_buffer_0;
20190         TALLOC_CTX *_mem_save_info_0;
20191         TALLOC_CTX *_mem_save_needed_0;
20192         TALLOC_CTX *_mem_save_count_0;
20193         if (flags & NDR_IN) {
20194                 ZERO_STRUCT(r->out);
20195
20196                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20197                 if (_ptr_server) {
20198                         NDR_PULL_ALLOC(ndr, r->in.server);
20199                 } else {
20200                         r->in.server = NULL;
20201                 }
20202                 if (r->in.server) {
20203                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20204                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20205                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20206                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20207                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20208                                 return 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));
20209                         }
20210                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20211                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20213                 }
20214                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20215                 if (_ptr_environment) {
20216                         NDR_PULL_ALLOC(ndr, r->in.environment);
20217                 } else {
20218                         r->in.environment = NULL;
20219                 }
20220                 if (r->in.environment) {
20221                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20222                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20223                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20224                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20225                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20226                                 return 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));
20227                         }
20228                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20229                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20230                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20231                 }
20232                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20233                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20234                 if (_ptr_buffer) {
20235                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20236                 } else {
20237                         r->in.buffer = NULL;
20238                 }
20239                 if (r->in.buffer) {
20240                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20241                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20242                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20243                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20244                 }
20245                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20246                 NDR_PULL_ALLOC(ndr, r->out.needed);
20247                 ZERO_STRUCTP(r->out.needed);
20248                 NDR_PULL_ALLOC(ndr, r->out.count);
20249                 ZERO_STRUCTP(r->out.count);
20250         }
20251         if (flags & NDR_OUT) {
20252                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20253                 if (_ptr_info) {
20254                         NDR_PULL_ALLOC(ndr, r->out.info);
20255                 } else {
20256                         r->out.info = NULL;
20257                 }
20258                 if (r->out.info) {
20259                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20260                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20261                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20263                 }
20264                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20265                         NDR_PULL_ALLOC(ndr, r->out.needed);
20266                 }
20267                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20268                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20270                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20271                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20272                         NDR_PULL_ALLOC(ndr, r->out.count);
20273                 }
20274                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20275                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20276                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20277                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20279         }
20280         return NDR_ERR_SUCCESS;
20281 }
20282
20283 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
20284 {
20285         uint32_t cntr_info_0;
20286         if (flags & NDR_IN) {
20287                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20289         }
20290         if (flags & NDR_OUT) {
20291                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20292                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20293                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20294                 }
20295                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20296                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20297                 }
20298         }
20299         return NDR_ERR_SUCCESS;
20300 }
20301
20302 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
20303 {
20304         uint32_t cntr_info_0;
20305         TALLOC_CTX *_mem_save_info_0;
20306         if (flags & NDR_IN) {
20307                 ZERO_STRUCT(r->out);
20308
20309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20311         }
20312         if (flags & NDR_OUT) {
20313                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20314                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20315                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20316                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20317                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20318                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20319                 }
20320                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20321                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20322                 }
20323                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20324         }
20325         return NDR_ERR_SUCCESS;
20326 }
20327
20328 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
20329 {
20330         uint32_t cntr_info_2;
20331         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
20332         ndr->depth++;
20333         if (flags & NDR_SET_VALUES) {
20334                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20335         }
20336         if (flags & NDR_IN) {
20337                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
20338                 ndr->depth++;
20339                 ndr_print_ptr(ndr, "server", r->in.server);
20340                 ndr->depth++;
20341                 if (r->in.server) {
20342                         ndr_print_string(ndr, "server", r->in.server);
20343                 }
20344                 ndr->depth--;
20345                 ndr_print_ptr(ndr, "environment", r->in.environment);
20346                 ndr->depth++;
20347                 if (r->in.environment) {
20348                         ndr_print_string(ndr, "environment", r->in.environment);
20349                 }
20350                 ndr->depth--;
20351                 ndr_print_uint32(ndr, "level", r->in.level);
20352                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20353                 ndr->depth++;
20354                 if (r->in.buffer) {
20355                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20356                 }
20357                 ndr->depth--;
20358                 ndr_print_uint32(ndr, "offered", r->in.offered);
20359                 ndr->depth--;
20360         }
20361         if (flags & NDR_OUT) {
20362                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
20363                 ndr->depth++;
20364                 ndr_print_ptr(ndr, "count", r->out.count);
20365                 ndr->depth++;
20366                 ndr_print_uint32(ndr, "count", *r->out.count);
20367                 ndr->depth--;
20368                 ndr_print_ptr(ndr, "info", r->out.info);
20369                 ndr->depth++;
20370                 ndr_print_ptr(ndr, "info", *r->out.info);
20371                 ndr->depth++;
20372                 if (*r->out.info) {
20373                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20374                         ndr->depth++;
20375                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20376                                 char *idx_2=NULL;
20377                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20378                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20379                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20380                                         free(idx_2);
20381                                 }
20382                         }
20383                         ndr->depth--;
20384                 }
20385                 ndr->depth--;
20386                 ndr->depth--;
20387                 ndr_print_ptr(ndr, "needed", r->out.needed);
20388                 ndr->depth++;
20389                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20390                 ndr->depth--;
20391                 ndr_print_WERROR(ndr, "result", r->out.result);
20392                 ndr->depth--;
20393         }
20394         ndr->depth--;
20395 }
20396
20397 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20398 {
20399         if (flags & NDR_IN) {
20400         }
20401         if (flags & NDR_OUT) {
20402                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20403         }
20404         return NDR_ERR_SUCCESS;
20405 }
20406
20407 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20408 {
20409         if (flags & NDR_IN) {
20410         }
20411         if (flags & NDR_OUT) {
20412                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20413         }
20414         return NDR_ERR_SUCCESS;
20415 }
20416
20417 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20418 {
20419         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
20420         ndr->depth++;
20421         if (flags & NDR_SET_VALUES) {
20422                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20423         }
20424         if (flags & NDR_IN) {
20425                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20426                 ndr->depth++;
20427                 ndr->depth--;
20428         }
20429         if (flags & NDR_OUT) {
20430                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20431                 ndr->depth++;
20432                 ndr_print_WERROR(ndr, "result", r->out.result);
20433                 ndr->depth--;
20434         }
20435         ndr->depth--;
20436 }
20437
20438 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20439 {
20440         if (flags & NDR_IN) {
20441                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20442                 if (r->in.server) {
20443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20447                 }
20448                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20449                 if (r->in.environment) {
20450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20451                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20453                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20454                 }
20455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20456                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20457                 if (r->in.buffer) {
20458                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20459                 }
20460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20461         }
20462         if (flags & NDR_OUT) {
20463                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20464                 if (r->out.info) {
20465                         {
20466                                 struct ndr_push *_ndr_info;
20467                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20468                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20469                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20470                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20471                         }
20472                 }
20473                 if (r->out.needed == NULL) {
20474                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20475                 }
20476                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20477                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20478         }
20479         return NDR_ERR_SUCCESS;
20480 }
20481
20482 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20483 {
20484         uint32_t _ptr_server;
20485         uint32_t _ptr_environment;
20486         uint32_t _ptr_buffer;
20487         uint32_t _ptr_info;
20488         TALLOC_CTX *_mem_save_server_0;
20489         TALLOC_CTX *_mem_save_environment_0;
20490         TALLOC_CTX *_mem_save_buffer_0;
20491         TALLOC_CTX *_mem_save_info_0;
20492         TALLOC_CTX *_mem_save_needed_0;
20493         if (flags & NDR_IN) {
20494                 ZERO_STRUCT(r->out);
20495
20496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20497                 if (_ptr_server) {
20498                         NDR_PULL_ALLOC(ndr, r->in.server);
20499                 } else {
20500                         r->in.server = NULL;
20501                 }
20502                 if (r->in.server) {
20503                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20504                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20505                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20506                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20507                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20508                                 return 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));
20509                         }
20510                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20511                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20512                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20513                 }
20514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20515                 if (_ptr_environment) {
20516                         NDR_PULL_ALLOC(ndr, r->in.environment);
20517                 } else {
20518                         r->in.environment = NULL;
20519                 }
20520                 if (r->in.environment) {
20521                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20522                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20523                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20524                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20525                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20526                                 return 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));
20527                         }
20528                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20529                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20530                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20531                 }
20532                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20534                 if (_ptr_buffer) {
20535                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20536                 } else {
20537                         r->in.buffer = NULL;
20538                 }
20539                 if (r->in.buffer) {
20540                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20541                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20542                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20543                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20544                 }
20545                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20546                 NDR_PULL_ALLOC(ndr, r->out.needed);
20547                 ZERO_STRUCTP(r->out.needed);
20548         }
20549         if (flags & NDR_OUT) {
20550                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20551                 if (_ptr_info) {
20552                         NDR_PULL_ALLOC(ndr, r->out.info);
20553                 } else {
20554                         r->out.info = NULL;
20555                 }
20556                 if (r->out.info) {
20557                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20558                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20559                         {
20560                                 struct ndr_pull *_ndr_info;
20561                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20562                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20563                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20564                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20565                         }
20566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20567                 }
20568                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20569                         NDR_PULL_ALLOC(ndr, r->out.needed);
20570                 }
20571                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20572                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20574                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20575                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20576         }
20577         return NDR_ERR_SUCCESS;
20578 }
20579
20580 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20581 {
20582         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20583         ndr->depth++;
20584         if (flags & NDR_SET_VALUES) {
20585                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20586         }
20587         if (flags & NDR_IN) {
20588                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20589                 ndr->depth++;
20590                 ndr_print_ptr(ndr, "server", r->in.server);
20591                 ndr->depth++;
20592                 if (r->in.server) {
20593                         ndr_print_string(ndr, "server", r->in.server);
20594                 }
20595                 ndr->depth--;
20596                 ndr_print_ptr(ndr, "environment", r->in.environment);
20597                 ndr->depth++;
20598                 if (r->in.environment) {
20599                         ndr_print_string(ndr, "environment", r->in.environment);
20600                 }
20601                 ndr->depth--;
20602                 ndr_print_uint32(ndr, "level", r->in.level);
20603                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20604                 ndr->depth++;
20605                 if (r->in.buffer) {
20606                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20607                 }
20608                 ndr->depth--;
20609                 ndr_print_uint32(ndr, "offered", r->in.offered);
20610                 ndr->depth--;
20611         }
20612         if (flags & NDR_OUT) {
20613                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20614                 ndr->depth++;
20615                 ndr_print_ptr(ndr, "info", r->out.info);
20616                 ndr->depth++;
20617                 if (r->out.info) {
20618                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20619                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20620                 }
20621                 ndr->depth--;
20622                 ndr_print_ptr(ndr, "needed", r->out.needed);
20623                 ndr->depth++;
20624                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20625                 ndr->depth--;
20626                 ndr_print_WERROR(ndr, "result", r->out.result);
20627                 ndr->depth--;
20628         }
20629         ndr->depth--;
20630 }
20631
20632 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20633 {
20634         if (flags & NDR_IN) {
20635                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20636                 if (r->in.server) {
20637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, 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.server, CH_UTF16)));
20640                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20641                 }
20642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20645                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20646                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20649                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20650         }
20651         if (flags & NDR_OUT) {
20652                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20653         }
20654         return NDR_ERR_SUCCESS;
20655 }
20656
20657 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20658 {
20659         uint32_t _ptr_server;
20660         TALLOC_CTX *_mem_save_server_0;
20661         if (flags & NDR_IN) {
20662                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20663                 if (_ptr_server) {
20664                         NDR_PULL_ALLOC(ndr, r->in.server);
20665                 } else {
20666                         r->in.server = NULL;
20667                 }
20668                 if (r->in.server) {
20669                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20670                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20671                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20672                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20673                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
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.server), ndr_get_array_length(ndr, &r->in.server));
20675                         }
20676                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20677                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20678                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20679                 }
20680                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20681                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20682                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20683                         return 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));
20684                 }
20685                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20686                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20687                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20688                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20689                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20690                         return 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));
20691                 }
20692                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20693                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20694         }
20695         if (flags & NDR_OUT) {
20696                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20697         }
20698         return NDR_ERR_SUCCESS;
20699 }
20700
20701 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20702 {
20703         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20704         ndr->depth++;
20705         if (flags & NDR_SET_VALUES) {
20706                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20707         }
20708         if (flags & NDR_IN) {
20709                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20710                 ndr->depth++;
20711                 ndr_print_ptr(ndr, "server", r->in.server);
20712                 ndr->depth++;
20713                 if (r->in.server) {
20714                         ndr_print_string(ndr, "server", r->in.server);
20715                 }
20716                 ndr->depth--;
20717                 ndr_print_string(ndr, "architecture", r->in.architecture);
20718                 ndr_print_string(ndr, "driver", r->in.driver);
20719                 ndr->depth--;
20720         }
20721         if (flags & NDR_OUT) {
20722                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20723                 ndr->depth++;
20724                 ndr_print_WERROR(ndr, "result", r->out.result);
20725                 ndr->depth--;
20726         }
20727         ndr->depth--;
20728 }
20729
20730 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20731 {
20732         if (flags & NDR_IN) {
20733                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20734                 if (r->in.server) {
20735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, 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.server, CH_UTF16)));
20738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20739                 }
20740                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20741                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20743                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20745                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20747                 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));
20748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20750                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20751                 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));
20752         }
20753         if (flags & NDR_OUT) {
20754                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20755         }
20756         return NDR_ERR_SUCCESS;
20757 }
20758
20759 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20760 {
20761         uint32_t _ptr_server;
20762         TALLOC_CTX *_mem_save_server_0;
20763         if (flags & NDR_IN) {
20764                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20765                 if (_ptr_server) {
20766                         NDR_PULL_ALLOC(ndr, r->in.server);
20767                 } else {
20768                         r->in.server = NULL;
20769                 }
20770                 if (r->in.server) {
20771                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20772                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20773                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20774                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20775                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
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.server), ndr_get_array_length(ndr, &r->in.server));
20777                         }
20778                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20779                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20780                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20781                 }
20782                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20783                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20784                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20785                         return 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));
20786                 }
20787                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20788                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20789                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20790                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20791                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20792                         return 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));
20793                 }
20794                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20795                 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));
20796                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20797                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20798                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20799                         return 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));
20800                 }
20801                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20802                 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));
20803         }
20804         if (flags & NDR_OUT) {
20805                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20806         }
20807         return NDR_ERR_SUCCESS;
20808 }
20809
20810 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20811 {
20812         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20813         ndr->depth++;
20814         if (flags & NDR_SET_VALUES) {
20815                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20816         }
20817         if (flags & NDR_IN) {
20818                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20819                 ndr->depth++;
20820                 ndr_print_ptr(ndr, "server", r->in.server);
20821                 ndr->depth++;
20822                 if (r->in.server) {
20823                         ndr_print_string(ndr, "server", r->in.server);
20824                 }
20825                 ndr->depth--;
20826                 ndr_print_string(ndr, "architecture", r->in.architecture);
20827                 ndr_print_string(ndr, "path_name", r->in.path_name);
20828                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20829                 ndr->depth--;
20830         }
20831         if (flags & NDR_OUT) {
20832                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20833                 ndr->depth++;
20834                 ndr_print_WERROR(ndr, "result", r->out.result);
20835                 ndr->depth--;
20836         }
20837         ndr->depth--;
20838 }
20839
20840 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20841 {
20842         if (flags & NDR_IN) {
20843                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20844                 if (r->in.servername) {
20845                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20846                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20847                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20848                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20849                 }
20850                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20851                 if (r->in.environment) {
20852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20853                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20854                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20855                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20856                 }
20857                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20858                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20859                 if (r->in.buffer) {
20860                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20861                 }
20862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20863         }
20864         if (flags & NDR_OUT) {
20865                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20866                 if (r->out.info) {
20867                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20868                 }
20869                 if (r->out.needed == NULL) {
20870                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20871                 }
20872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20873                 if (r->out.count == NULL) {
20874                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20875                 }
20876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20877                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20878         }
20879         return NDR_ERR_SUCCESS;
20880 }
20881
20882 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20883 {
20884         uint32_t _ptr_servername;
20885         uint32_t _ptr_environment;
20886         uint32_t _ptr_buffer;
20887         uint32_t _ptr_info;
20888         TALLOC_CTX *_mem_save_servername_0;
20889         TALLOC_CTX *_mem_save_environment_0;
20890         TALLOC_CTX *_mem_save_buffer_0;
20891         TALLOC_CTX *_mem_save_info_0;
20892         TALLOC_CTX *_mem_save_needed_0;
20893         TALLOC_CTX *_mem_save_count_0;
20894         if (flags & NDR_IN) {
20895                 ZERO_STRUCT(r->out);
20896
20897                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20898                 if (_ptr_servername) {
20899                         NDR_PULL_ALLOC(ndr, r->in.servername);
20900                 } else {
20901                         r->in.servername = NULL;
20902                 }
20903                 if (r->in.servername) {
20904                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20905                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20906                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20907                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20908                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20909                                 return 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));
20910                         }
20911                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20912                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20914                 }
20915                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20916                 if (_ptr_environment) {
20917                         NDR_PULL_ALLOC(ndr, r->in.environment);
20918                 } else {
20919                         r->in.environment = NULL;
20920                 }
20921                 if (r->in.environment) {
20922                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20923                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20924                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20925                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20926                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20927                                 return 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));
20928                         }
20929                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20930                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20931                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20932                 }
20933                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20934                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20935                 if (_ptr_buffer) {
20936                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20937                 } else {
20938                         r->in.buffer = NULL;
20939                 }
20940                 if (r->in.buffer) {
20941                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20942                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20943                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20944                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20945                 }
20946                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20947                 NDR_PULL_ALLOC(ndr, r->out.needed);
20948                 ZERO_STRUCTP(r->out.needed);
20949                 NDR_PULL_ALLOC(ndr, r->out.count);
20950                 ZERO_STRUCTP(r->out.count);
20951         }
20952         if (flags & NDR_OUT) {
20953                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20954                 if (_ptr_info) {
20955                         NDR_PULL_ALLOC(ndr, r->out.info);
20956                 } else {
20957                         r->out.info = NULL;
20958                 }
20959                 if (r->out.info) {
20960                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20961                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20962                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20963                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20964                 }
20965                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20966                         NDR_PULL_ALLOC(ndr, r->out.needed);
20967                 }
20968                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20969                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20970                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20971                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20972                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20973                         NDR_PULL_ALLOC(ndr, r->out.count);
20974                 }
20975                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20976                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20977                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20978                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20979                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20980         }
20981         return NDR_ERR_SUCCESS;
20982 }
20983
20984 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20985 {
20986         uint32_t cntr_info_0;
20987         if (flags & NDR_IN) {
20988                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20989                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20990         }
20991         if (flags & NDR_OUT) {
20992                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20993                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20994                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20995                 }
20996                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20997                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20998                 }
20999         }
21000         return NDR_ERR_SUCCESS;
21001 }
21002
21003 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
21004 {
21005         uint32_t cntr_info_0;
21006         TALLOC_CTX *_mem_save_info_0;
21007         if (flags & NDR_IN) {
21008                 ZERO_STRUCT(r->out);
21009
21010                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21011                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
21012         }
21013         if (flags & NDR_OUT) {
21014                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
21015                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21016                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21017                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21018                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
21019                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
21020                 }
21021                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
21022                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
21023                 }
21024                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21025         }
21026         return NDR_ERR_SUCCESS;
21027 }
21028
21029 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
21030 {
21031         uint32_t cntr_info_2;
21032         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
21033         ndr->depth++;
21034         if (flags & NDR_SET_VALUES) {
21035                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21036         }
21037         if (flags & NDR_IN) {
21038                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
21039                 ndr->depth++;
21040                 ndr_print_ptr(ndr, "servername", r->in.servername);
21041                 ndr->depth++;
21042                 if (r->in.servername) {
21043                         ndr_print_string(ndr, "servername", r->in.servername);
21044                 }
21045                 ndr->depth--;
21046                 ndr_print_ptr(ndr, "environment", r->in.environment);
21047                 ndr->depth++;
21048                 if (r->in.environment) {
21049                         ndr_print_string(ndr, "environment", r->in.environment);
21050                 }
21051                 ndr->depth--;
21052                 ndr_print_uint32(ndr, "level", r->in.level);
21053                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21054                 ndr->depth++;
21055                 if (r->in.buffer) {
21056                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21057                 }
21058                 ndr->depth--;
21059                 ndr_print_uint32(ndr, "offered", r->in.offered);
21060                 ndr->depth--;
21061         }
21062         if (flags & NDR_OUT) {
21063                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
21064                 ndr->depth++;
21065                 ndr_print_ptr(ndr, "count", r->out.count);
21066                 ndr->depth++;
21067                 ndr_print_uint32(ndr, "count", *r->out.count);
21068                 ndr->depth--;
21069                 ndr_print_ptr(ndr, "info", r->out.info);
21070                 ndr->depth++;
21071                 ndr_print_ptr(ndr, "info", *r->out.info);
21072                 ndr->depth++;
21073                 if (*r->out.info) {
21074                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
21075                         ndr->depth++;
21076                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
21077                                 char *idx_2=NULL;
21078                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
21079                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
21080                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
21081                                         free(idx_2);
21082                                 }
21083                         }
21084                         ndr->depth--;
21085                 }
21086                 ndr->depth--;
21087                 ndr->depth--;
21088                 ndr_print_ptr(ndr, "needed", r->out.needed);
21089                 ndr->depth++;
21090                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21091                 ndr->depth--;
21092                 ndr_print_WERROR(ndr, "result", r->out.result);
21093                 ndr->depth--;
21094         }
21095         ndr->depth--;
21096 }
21097
21098 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21099 {
21100         if (flags & NDR_IN) {
21101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
21102                 if (r->in.server) {
21103                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21104                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21106                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21107                 }
21108                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21109                 if (r->in.environment) {
21110                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21113                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21114                 }
21115                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21116                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21117                 if (r->in.buffer) {
21118                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21119                 }
21120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21121         }
21122         if (flags & NDR_OUT) {
21123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21124                 if (r->out.info) {
21125                         {
21126                                 struct ndr_push *_ndr_info;
21127                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21128                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21129                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21130                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21131                         }
21132                 }
21133                 if (r->out.needed == NULL) {
21134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21135                 }
21136                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21137                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21138         }
21139         return NDR_ERR_SUCCESS;
21140 }
21141
21142 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
21143 {
21144         uint32_t _ptr_server;
21145         uint32_t _ptr_environment;
21146         uint32_t _ptr_buffer;
21147         uint32_t _ptr_info;
21148         TALLOC_CTX *_mem_save_server_0;
21149         TALLOC_CTX *_mem_save_environment_0;
21150         TALLOC_CTX *_mem_save_buffer_0;
21151         TALLOC_CTX *_mem_save_info_0;
21152         TALLOC_CTX *_mem_save_needed_0;
21153         if (flags & NDR_IN) {
21154                 ZERO_STRUCT(r->out);
21155
21156                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21157                 if (_ptr_server) {
21158                         NDR_PULL_ALLOC(ndr, r->in.server);
21159                 } else {
21160                         r->in.server = NULL;
21161                 }
21162                 if (r->in.server) {
21163                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21164                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21165                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21166                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21167                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21168                                 return 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));
21169                         }
21170                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21171                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21172                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21173                 }
21174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21175                 if (_ptr_environment) {
21176                         NDR_PULL_ALLOC(ndr, r->in.environment);
21177                 } else {
21178                         r->in.environment = NULL;
21179                 }
21180                 if (r->in.environment) {
21181                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21182                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21183                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21184                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21185                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21186                                 return 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));
21187                         }
21188                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21189                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21190                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21191                 }
21192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21194                 if (_ptr_buffer) {
21195                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21196                 } else {
21197                         r->in.buffer = NULL;
21198                 }
21199                 if (r->in.buffer) {
21200                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21201                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21202                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21204                 }
21205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21206                 NDR_PULL_ALLOC(ndr, r->out.needed);
21207                 ZERO_STRUCTP(r->out.needed);
21208         }
21209         if (flags & NDR_OUT) {
21210                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21211                 if (_ptr_info) {
21212                         NDR_PULL_ALLOC(ndr, r->out.info);
21213                 } else {
21214                         r->out.info = NULL;
21215                 }
21216                 if (r->out.info) {
21217                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21218                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21219                         {
21220                                 struct ndr_pull *_ndr_info;
21221                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21222                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21223                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21224                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21225                         }
21226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21227                 }
21228                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21229                         NDR_PULL_ALLOC(ndr, r->out.needed);
21230                 }
21231                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21232                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21235                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21236         }
21237         return NDR_ERR_SUCCESS;
21238 }
21239
21240 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21241 {
21242         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
21243         ndr->depth++;
21244         if (flags & NDR_SET_VALUES) {
21245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21246         }
21247         if (flags & NDR_IN) {
21248                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
21249                 ndr->depth++;
21250                 ndr_print_ptr(ndr, "server", r->in.server);
21251                 ndr->depth++;
21252                 if (r->in.server) {
21253                         ndr_print_string(ndr, "server", r->in.server);
21254                 }
21255                 ndr->depth--;
21256                 ndr_print_ptr(ndr, "environment", r->in.environment);
21257                 ndr->depth++;
21258                 if (r->in.environment) {
21259                         ndr_print_string(ndr, "environment", r->in.environment);
21260                 }
21261                 ndr->depth--;
21262                 ndr_print_uint32(ndr, "level", r->in.level);
21263                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21264                 ndr->depth++;
21265                 if (r->in.buffer) {
21266                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21267                 }
21268                 ndr->depth--;
21269                 ndr_print_uint32(ndr, "offered", r->in.offered);
21270                 ndr->depth--;
21271         }
21272         if (flags & NDR_OUT) {
21273                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
21274                 ndr->depth++;
21275                 ndr_print_ptr(ndr, "info", r->out.info);
21276                 ndr->depth++;
21277                 if (r->out.info) {
21278                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21279                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
21280                 }
21281                 ndr->depth--;
21282                 ndr_print_ptr(ndr, "needed", r->out.needed);
21283                 ndr->depth++;
21284                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21285                 ndr->depth--;
21286                 ndr_print_WERROR(ndr, "result", r->out.result);
21287                 ndr->depth--;
21288         }
21289         ndr->depth--;
21290 }
21291
21292 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
21293 {
21294         if (flags & NDR_IN) {
21295                 if (r->in.handle == NULL) {
21296                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21297                 }
21298                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21300                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21301                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21302         }
21303         if (flags & NDR_OUT) {
21304                 if (r->out.job_id == NULL) {
21305                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21306                 }
21307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
21308                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21309         }
21310         return NDR_ERR_SUCCESS;
21311 }
21312
21313 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
21314 {
21315         TALLOC_CTX *_mem_save_handle_0;
21316         TALLOC_CTX *_mem_save_job_id_0;
21317         if (flags & NDR_IN) {
21318                 ZERO_STRUCT(r->out);
21319
21320                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21321                         NDR_PULL_ALLOC(ndr, r->in.handle);
21322                 }
21323                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21324                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21325                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21326                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21328                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21329                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21330                 NDR_PULL_ALLOC(ndr, r->out.job_id);
21331                 ZERO_STRUCTP(r->out.job_id);
21332         }
21333         if (flags & NDR_OUT) {
21334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21335                         NDR_PULL_ALLOC(ndr, r->out.job_id);
21336                 }
21337                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
21338                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
21339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
21340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
21341                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21342         }
21343         return NDR_ERR_SUCCESS;
21344 }
21345
21346 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
21347 {
21348         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
21349         ndr->depth++;
21350         if (flags & NDR_SET_VALUES) {
21351                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21352         }
21353         if (flags & NDR_IN) {
21354                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
21355                 ndr->depth++;
21356                 ndr_print_ptr(ndr, "handle", r->in.handle);
21357                 ndr->depth++;
21358                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21359                 ndr->depth--;
21360                 ndr_print_uint32(ndr, "level", r->in.level);
21361                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21362                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
21363                 ndr->depth--;
21364         }
21365         if (flags & NDR_OUT) {
21366                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
21367                 ndr->depth++;
21368                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
21369                 ndr->depth++;
21370                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
21371                 ndr->depth--;
21372                 ndr_print_WERROR(ndr, "result", r->out.result);
21373                 ndr->depth--;
21374         }
21375         ndr->depth--;
21376 }
21377
21378 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
21379 {
21380         if (flags & NDR_IN) {
21381                 if (r->in.handle == NULL) {
21382                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21383                 }
21384                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21385         }
21386         if (flags & NDR_OUT) {
21387                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21388         }
21389         return NDR_ERR_SUCCESS;
21390 }
21391
21392 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
21393 {
21394         TALLOC_CTX *_mem_save_handle_0;
21395         if (flags & NDR_IN) {
21396                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21397                         NDR_PULL_ALLOC(ndr, r->in.handle);
21398                 }
21399                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21400                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21401                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21402                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21403         }
21404         if (flags & NDR_OUT) {
21405                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21406         }
21407         return NDR_ERR_SUCCESS;
21408 }
21409
21410 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
21411 {
21412         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
21413         ndr->depth++;
21414         if (flags & NDR_SET_VALUES) {
21415                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21416         }
21417         if (flags & NDR_IN) {
21418                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
21419                 ndr->depth++;
21420                 ndr_print_ptr(ndr, "handle", r->in.handle);
21421                 ndr->depth++;
21422                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21423                 ndr->depth--;
21424                 ndr->depth--;
21425         }
21426         if (flags & NDR_OUT) {
21427                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21428                 ndr->depth++;
21429                 ndr_print_WERROR(ndr, "result", r->out.result);
21430                 ndr->depth--;
21431         }
21432         ndr->depth--;
21433 }
21434
21435 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21436 {
21437         if (flags & NDR_IN) {
21438                 if (r->in.handle == NULL) {
21439                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21440                 }
21441                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21442                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21444         }
21445         if (flags & NDR_OUT) {
21446                 if (r->out.num_written == NULL) {
21447                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21448                 }
21449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21450                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21451         }
21452         return NDR_ERR_SUCCESS;
21453 }
21454
21455 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21456 {
21457         TALLOC_CTX *_mem_save_handle_0;
21458         TALLOC_CTX *_mem_save_num_written_0;
21459         if (flags & NDR_IN) {
21460                 ZERO_STRUCT(r->out);
21461
21462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21463                         NDR_PULL_ALLOC(ndr, r->in.handle);
21464                 }
21465                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21466                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21467                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21469                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21470                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21471                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21472                 ZERO_STRUCTP(r->out.num_written);
21473         }
21474         if (flags & NDR_OUT) {
21475                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21476                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21477                 }
21478                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21479                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21480                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21481                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21482                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21483         }
21484         return NDR_ERR_SUCCESS;
21485 }
21486
21487 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21488 {
21489         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21490         ndr->depth++;
21491         if (flags & NDR_SET_VALUES) {
21492                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21493         }
21494         if (flags & NDR_IN) {
21495                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21496                 ndr->depth++;
21497                 ndr_print_ptr(ndr, "handle", r->in.handle);
21498                 ndr->depth++;
21499                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21500                 ndr->depth--;
21501                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21502                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21503                 ndr->depth--;
21504         }
21505         if (flags & NDR_OUT) {
21506                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21507                 ndr->depth++;
21508                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21509                 ndr->depth++;
21510                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21511                 ndr->depth--;
21512                 ndr_print_WERROR(ndr, "result", r->out.result);
21513                 ndr->depth--;
21514         }
21515         ndr->depth--;
21516 }
21517
21518 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21519 {
21520         if (flags & NDR_IN) {
21521                 if (r->in.handle == NULL) {
21522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21523                 }
21524                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21525         }
21526         if (flags & NDR_OUT) {
21527                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21528         }
21529         return NDR_ERR_SUCCESS;
21530 }
21531
21532 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21533 {
21534         TALLOC_CTX *_mem_save_handle_0;
21535         if (flags & NDR_IN) {
21536                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21537                         NDR_PULL_ALLOC(ndr, r->in.handle);
21538                 }
21539                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21540                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21541                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21542                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21543         }
21544         if (flags & NDR_OUT) {
21545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21546         }
21547         return NDR_ERR_SUCCESS;
21548 }
21549
21550 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21551 {
21552         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21553         ndr->depth++;
21554         if (flags & NDR_SET_VALUES) {
21555                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21556         }
21557         if (flags & NDR_IN) {
21558                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21559                 ndr->depth++;
21560                 ndr_print_ptr(ndr, "handle", r->in.handle);
21561                 ndr->depth++;
21562                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21563                 ndr->depth--;
21564                 ndr->depth--;
21565         }
21566         if (flags & NDR_OUT) {
21567                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21568                 ndr->depth++;
21569                 ndr_print_WERROR(ndr, "result", r->out.result);
21570                 ndr->depth--;
21571         }
21572         ndr->depth--;
21573 }
21574
21575 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21576 {
21577         if (flags & NDR_IN) {
21578                 if (r->in.handle == NULL) {
21579                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21580                 }
21581                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21582         }
21583         if (flags & NDR_OUT) {
21584                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21585         }
21586         return NDR_ERR_SUCCESS;
21587 }
21588
21589 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21590 {
21591         TALLOC_CTX *_mem_save_handle_0;
21592         if (flags & NDR_IN) {
21593                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21594                         NDR_PULL_ALLOC(ndr, r->in.handle);
21595                 }
21596                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21597                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21598                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21600         }
21601         if (flags & NDR_OUT) {
21602                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21603         }
21604         return NDR_ERR_SUCCESS;
21605 }
21606
21607 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21608 {
21609         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21610         ndr->depth++;
21611         if (flags & NDR_SET_VALUES) {
21612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21613         }
21614         if (flags & NDR_IN) {
21615                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21616                 ndr->depth++;
21617                 ndr_print_ptr(ndr, "handle", r->in.handle);
21618                 ndr->depth++;
21619                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21620                 ndr->depth--;
21621                 ndr->depth--;
21622         }
21623         if (flags & NDR_OUT) {
21624                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21625                 ndr->depth++;
21626                 ndr_print_WERROR(ndr, "result", r->out.result);
21627                 ndr->depth--;
21628         }
21629         ndr->depth--;
21630 }
21631
21632 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21633 {
21634         if (flags & NDR_IN) {
21635                 if (r->in.handle == NULL) {
21636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21637                 }
21638                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21640         }
21641         if (flags & NDR_OUT) {
21642                 if (r->out.data == NULL) {
21643                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21644                 }
21645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21646                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21647                 if (r->out._data_size == NULL) {
21648                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21649                 }
21650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21651                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21652         }
21653         return NDR_ERR_SUCCESS;
21654 }
21655
21656 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21657 {
21658         TALLOC_CTX *_mem_save_handle_0;
21659         TALLOC_CTX *_mem_save__data_size_0;
21660         if (flags & NDR_IN) {
21661                 ZERO_STRUCT(r->out);
21662
21663                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21664                         NDR_PULL_ALLOC(ndr, r->in.handle);
21665                 }
21666                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21667                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21668                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21669                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21670                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21671                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21672                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21673                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21674                 ZERO_STRUCTP(r->out._data_size);
21675         }
21676         if (flags & NDR_OUT) {
21677                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21678                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21679                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21680                 }
21681                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21682                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21683                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21684                 }
21685                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21686                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21688                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21689                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21690                 if (r->out.data) {
21691                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21692                 }
21693         }
21694         return NDR_ERR_SUCCESS;
21695 }
21696
21697 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21698 {
21699         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21700         ndr->depth++;
21701         if (flags & NDR_SET_VALUES) {
21702                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21703         }
21704         if (flags & NDR_IN) {
21705                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21706                 ndr->depth++;
21707                 ndr_print_ptr(ndr, "handle", r->in.handle);
21708                 ndr->depth++;
21709                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21710                 ndr->depth--;
21711                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21712                 ndr->depth--;
21713         }
21714         if (flags & NDR_OUT) {
21715                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21716                 ndr->depth++;
21717                 ndr_print_ptr(ndr, "data", r->out.data);
21718                 ndr->depth++;
21719                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21720                 ndr->depth--;
21721                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21722                 ndr->depth++;
21723                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21724                 ndr->depth--;
21725                 ndr_print_WERROR(ndr, "result", r->out.result);
21726                 ndr->depth--;
21727         }
21728         ndr->depth--;
21729 }
21730
21731 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21732 {
21733         if (flags & NDR_IN) {
21734                 if (r->in.handle == NULL) {
21735                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21736                 }
21737                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21738         }
21739         if (flags & NDR_OUT) {
21740                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21741         }
21742         return NDR_ERR_SUCCESS;
21743 }
21744
21745 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21746 {
21747         TALLOC_CTX *_mem_save_handle_0;
21748         if (flags & NDR_IN) {
21749                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21750                         NDR_PULL_ALLOC(ndr, r->in.handle);
21751                 }
21752                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21753                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21754                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21755                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21756         }
21757         if (flags & NDR_OUT) {
21758                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21759         }
21760         return NDR_ERR_SUCCESS;
21761 }
21762
21763 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21764 {
21765         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21766         ndr->depth++;
21767         if (flags & NDR_SET_VALUES) {
21768                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21769         }
21770         if (flags & NDR_IN) {
21771                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21772                 ndr->depth++;
21773                 ndr_print_ptr(ndr, "handle", r->in.handle);
21774                 ndr->depth++;
21775                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21776                 ndr->depth--;
21777                 ndr->depth--;
21778         }
21779         if (flags & NDR_OUT) {
21780                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21781                 ndr->depth++;
21782                 ndr_print_WERROR(ndr, "result", r->out.result);
21783                 ndr->depth--;
21784         }
21785         ndr->depth--;
21786 }
21787
21788 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21789 {
21790         if (flags & NDR_IN) {
21791                 if (r->in.handle == NULL) {
21792                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21793                 }
21794                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21797                 if (r->in.buffer) {
21798                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21799                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21800                 }
21801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21802         }
21803         if (flags & NDR_OUT) {
21804                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21805                 if (r->out.buffer) {
21806                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21807                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21808                 }
21809                 if (r->out.needed == NULL) {
21810                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21811                 }
21812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21813                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21814         }
21815         return NDR_ERR_SUCCESS;
21816 }
21817
21818 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21819 {
21820         uint32_t _ptr_buffer;
21821         TALLOC_CTX *_mem_save_handle_0;
21822         TALLOC_CTX *_mem_save_buffer_0;
21823         TALLOC_CTX *_mem_save_needed_0;
21824         if (flags & NDR_IN) {
21825                 ZERO_STRUCT(r->out);
21826
21827                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21828                         NDR_PULL_ALLOC(ndr, r->in.handle);
21829                 }
21830                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21831                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21832                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21833                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21834                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21836                 if (_ptr_buffer) {
21837                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21838                 } else {
21839                         r->in.buffer = NULL;
21840                 }
21841                 if (r->in.buffer) {
21842                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21843                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21844                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21845                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21846                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21847                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21848                 }
21849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21850                 NDR_PULL_ALLOC(ndr, r->out.needed);
21851                 ZERO_STRUCTP(r->out.needed);
21852                 if (r->in.buffer) {
21853                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21854                 }
21855         }
21856         if (flags & NDR_OUT) {
21857                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21858                 if (_ptr_buffer) {
21859                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21860                 } else {
21861                         r->out.buffer = NULL;
21862                 }
21863                 if (r->out.buffer) {
21864                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21865                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21867                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21868                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21869                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21870                 }
21871                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21872                         NDR_PULL_ALLOC(ndr, r->out.needed);
21873                 }
21874                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21875                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21877                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21878                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21879                 if (r->out.buffer) {
21880                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21881                 }
21882         }
21883         return NDR_ERR_SUCCESS;
21884 }
21885
21886 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21887 {
21888         ndr_print_struct(ndr, name, "spoolss_AddJob");
21889         ndr->depth++;
21890         if (flags & NDR_SET_VALUES) {
21891                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21892         }
21893         if (flags & NDR_IN) {
21894                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21895                 ndr->depth++;
21896                 ndr_print_ptr(ndr, "handle", r->in.handle);
21897                 ndr->depth++;
21898                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21899                 ndr->depth--;
21900                 ndr_print_uint32(ndr, "level", r->in.level);
21901                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21902                 ndr->depth++;
21903                 if (r->in.buffer) {
21904                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21905                 }
21906                 ndr->depth--;
21907                 ndr_print_uint32(ndr, "offered", r->in.offered);
21908                 ndr->depth--;
21909         }
21910         if (flags & NDR_OUT) {
21911                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21912                 ndr->depth++;
21913                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21914                 ndr->depth++;
21915                 if (r->out.buffer) {
21916                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21917                 }
21918                 ndr->depth--;
21919                 ndr_print_ptr(ndr, "needed", r->out.needed);
21920                 ndr->depth++;
21921                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21922                 ndr->depth--;
21923                 ndr_print_WERROR(ndr, "result", r->out.result);
21924                 ndr->depth--;
21925         }
21926         ndr->depth--;
21927 }
21928
21929 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21930 {
21931         if (flags & NDR_IN) {
21932                 if (r->in.handle == NULL) {
21933                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21934                 }
21935                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21936                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21937         }
21938         if (flags & NDR_OUT) {
21939                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21940         }
21941         return NDR_ERR_SUCCESS;
21942 }
21943
21944 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21945 {
21946         TALLOC_CTX *_mem_save_handle_0;
21947         if (flags & NDR_IN) {
21948                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21949                         NDR_PULL_ALLOC(ndr, r->in.handle);
21950                 }
21951                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21952                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21953                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21955                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21956         }
21957         if (flags & NDR_OUT) {
21958                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21959         }
21960         return NDR_ERR_SUCCESS;
21961 }
21962
21963 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21964 {
21965         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21966         ndr->depth++;
21967         if (flags & NDR_SET_VALUES) {
21968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21969         }
21970         if (flags & NDR_IN) {
21971                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21972                 ndr->depth++;
21973                 ndr_print_ptr(ndr, "handle", r->in.handle);
21974                 ndr->depth++;
21975                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21976                 ndr->depth--;
21977                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21978                 ndr->depth--;
21979         }
21980         if (flags & NDR_OUT) {
21981                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21982                 ndr->depth++;
21983                 ndr_print_WERROR(ndr, "result", r->out.result);
21984                 ndr->depth--;
21985         }
21986         ndr->depth--;
21987 }
21988
21989 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21990 {
21991         if (flags & NDR_IN) {
21992                 if (r->in.handle == NULL) {
21993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21994                 }
21995                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21999                 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));
22000                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22001         }
22002         if (flags & NDR_OUT) {
22003                 if (r->out.type == NULL) {
22004                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22005                 }
22006                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
22007                 if (r->out.data == NULL) {
22008                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22009                 }
22010                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
22011                 if (r->out.needed == NULL) {
22012                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22013                 }
22014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22015                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22016         }
22017         return NDR_ERR_SUCCESS;
22018 }
22019
22020 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
22021 {
22022         TALLOC_CTX *_mem_save_handle_0;
22023         TALLOC_CTX *_mem_save_type_0;
22024         TALLOC_CTX *_mem_save_data_0;
22025         TALLOC_CTX *_mem_save_needed_0;
22026         if (flags & NDR_IN) {
22027                 ZERO_STRUCT(r->out);
22028
22029                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22030                         NDR_PULL_ALLOC(ndr, r->in.handle);
22031                 }
22032                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22033                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22034                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22035                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22036                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22037                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22038                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22039                         return 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));
22040                 }
22041                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22042                 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));
22043                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22044                 NDR_PULL_ALLOC(ndr, r->out.type);
22045                 ZERO_STRUCTP(r->out.type);
22046                 NDR_PULL_ALLOC(ndr, r->out.data);
22047                 ZERO_STRUCTP(r->out.data);
22048                 NDR_PULL_ALLOC(ndr, r->out.needed);
22049                 ZERO_STRUCTP(r->out.needed);
22050         }
22051         if (flags & NDR_OUT) {
22052                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22053                         NDR_PULL_ALLOC(ndr, r->out.type);
22054                 }
22055                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
22056                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
22057                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
22058                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
22059                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22060                         NDR_PULL_ALLOC(ndr, r->out.data);
22061                 }
22062                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22063                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22064                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
22065                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22066                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22067                         NDR_PULL_ALLOC(ndr, r->out.needed);
22068                 }
22069                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22070                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22072                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22073                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22074         }
22075         return NDR_ERR_SUCCESS;
22076 }
22077
22078 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
22079 {
22080         if (flags & NDR_IN) {
22081                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22082         }
22083         if (flags & NDR_OUT) {
22084                 if (r->out.data == NULL) {
22085                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22086                 }
22087                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22088                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22089         }
22090         return NDR_ERR_SUCCESS;
22091 }
22092
22093 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
22094 {
22095         TALLOC_CTX *_mem_save_data_0;
22096         if (flags & NDR_IN) {
22097                 ZERO_STRUCT(r->out);
22098
22099                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22100                 NDR_PULL_ALLOC(ndr, r->out.data);
22101                 ZERO_STRUCTP(r->out.data);
22102         }
22103         if (flags & NDR_OUT) {
22104                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22105                         NDR_PULL_ALLOC(ndr, r->out.data);
22106                 }
22107                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22108                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22109                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
22110                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22111                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22112         }
22113         return NDR_ERR_SUCCESS;
22114 }
22115
22116 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
22117 {
22118         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
22119         ndr->depth++;
22120         if (flags & NDR_SET_VALUES) {
22121                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22122         }
22123         if (flags & NDR_IN) {
22124                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
22125                 ndr->depth++;
22126                 ndr_print_ptr(ndr, "handle", r->in.handle);
22127                 ndr->depth++;
22128                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22129                 ndr->depth--;
22130                 ndr_print_string(ndr, "value_name", r->in.value_name);
22131                 ndr_print_uint32(ndr, "offered", r->in.offered);
22132                 ndr->depth--;
22133         }
22134         if (flags & NDR_OUT) {
22135                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
22136                 ndr->depth++;
22137                 ndr_print_ptr(ndr, "type", r->out.type);
22138                 ndr->depth++;
22139                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
22140                 ndr->depth--;
22141                 ndr_print_ptr(ndr, "data", r->out.data);
22142                 ndr->depth++;
22143                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
22144                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
22145                 ndr->depth--;
22146                 ndr_print_ptr(ndr, "needed", r->out.needed);
22147                 ndr->depth++;
22148                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22149                 ndr->depth--;
22150                 ndr_print_WERROR(ndr, "result", r->out.result);
22151                 ndr->depth--;
22152         }
22153         ndr->depth--;
22154 }
22155
22156 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
22157 {
22158         if (flags & NDR_IN) {
22159                 if (r->in.handle == NULL) {
22160                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22161                 }
22162                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22163                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22166                 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));
22167                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22168                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
22170         }
22171         if (flags & NDR_OUT) {
22172                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22173         }
22174         return NDR_ERR_SUCCESS;
22175 }
22176
22177 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
22178 {
22179         if (flags & NDR_IN) {
22180                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22181         }
22182         if (flags & NDR_OUT) {
22183                 if (r->out.data == NULL) {
22184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22185                 }
22186                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22187                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22188         }
22189         return NDR_ERR_SUCCESS;
22190 }
22191
22192 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
22193 {
22194         TALLOC_CTX *_mem_save_handle_0;
22195         if (flags & NDR_IN) {
22196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22197                         NDR_PULL_ALLOC(ndr, r->in.handle);
22198                 }
22199                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22200                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22201                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22202                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22203                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22204                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22205                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22206                         return 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));
22207                 }
22208                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22209                 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));
22210                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22211                 {
22212                         struct ndr_pull *_ndr_data;
22213                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
22214                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
22215                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
22216                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
22217                 }
22218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
22219         }
22220         if (flags & NDR_OUT) {
22221                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22222         }
22223         return NDR_ERR_SUCCESS;
22224 }
22225
22226 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
22227 {
22228         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
22229         ndr->depth++;
22230         if (flags & NDR_SET_VALUES) {
22231                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22232         }
22233         if (flags & NDR_IN) {
22234                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
22235                 ndr->depth++;
22236                 ndr_print_ptr(ndr, "handle", r->in.handle);
22237                 ndr->depth++;
22238                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22239                 ndr->depth--;
22240                 ndr_print_string(ndr, "value_name", r->in.value_name);
22241                 ndr_print_winreg_Type(ndr, "type", r->in.type);
22242                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
22243                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
22244                 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);
22245                 ndr->depth--;
22246         }
22247         if (flags & NDR_OUT) {
22248                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
22249                 ndr->depth++;
22250                 ndr_print_WERROR(ndr, "result", r->out.result);
22251                 ndr->depth--;
22252         }
22253         ndr->depth--;
22254 }
22255
22256 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
22257 {
22258         if (flags & NDR_IN) {
22259         }
22260         if (flags & NDR_OUT) {
22261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22262         }
22263         return NDR_ERR_SUCCESS;
22264 }
22265
22266 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
22267 {
22268         if (flags & NDR_IN) {
22269         }
22270         if (flags & NDR_OUT) {
22271                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22272         }
22273         return NDR_ERR_SUCCESS;
22274 }
22275
22276 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
22277 {
22278         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
22279         ndr->depth++;
22280         if (flags & NDR_SET_VALUES) {
22281                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22282         }
22283         if (flags & NDR_IN) {
22284                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
22285                 ndr->depth++;
22286                 ndr->depth--;
22287         }
22288         if (flags & NDR_OUT) {
22289                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
22290                 ndr->depth++;
22291                 ndr_print_WERROR(ndr, "result", r->out.result);
22292                 ndr->depth--;
22293         }
22294         ndr->depth--;
22295 }
22296
22297 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
22298 {
22299         if (flags & NDR_IN) {
22300                 if (r->in.handle == NULL) {
22301                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22302                 }
22303                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22304         }
22305         if (flags & NDR_OUT) {
22306                 if (r->out.handle == NULL) {
22307                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22308                 }
22309                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22310                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22311         }
22312         return NDR_ERR_SUCCESS;
22313 }
22314
22315 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
22316 {
22317         TALLOC_CTX *_mem_save_handle_0;
22318         if (flags & NDR_IN) {
22319                 ZERO_STRUCT(r->out);
22320
22321                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22322                         NDR_PULL_ALLOC(ndr, r->in.handle);
22323                 }
22324                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22325                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22326                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22327                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22328                 NDR_PULL_ALLOC(ndr, r->out.handle);
22329                 *r->out.handle = *r->in.handle;
22330         }
22331         if (flags & NDR_OUT) {
22332                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22333                         NDR_PULL_ALLOC(ndr, r->out.handle);
22334                 }
22335                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22336                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22337                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22338                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22339                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22340         }
22341         return NDR_ERR_SUCCESS;
22342 }
22343
22344 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
22345 {
22346         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
22347         ndr->depth++;
22348         if (flags & NDR_SET_VALUES) {
22349                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22350         }
22351         if (flags & NDR_IN) {
22352                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
22353                 ndr->depth++;
22354                 ndr_print_ptr(ndr, "handle", r->in.handle);
22355                 ndr->depth++;
22356                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22357                 ndr->depth--;
22358                 ndr->depth--;
22359         }
22360         if (flags & NDR_OUT) {
22361                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
22362                 ndr->depth++;
22363                 ndr_print_ptr(ndr, "handle", r->out.handle);
22364                 ndr->depth++;
22365                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22366                 ndr->depth--;
22367                 ndr_print_WERROR(ndr, "result", r->out.result);
22368                 ndr->depth--;
22369         }
22370         ndr->depth--;
22371 }
22372
22373 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
22374 {
22375         if (flags & NDR_IN) {
22376                 if (r->in.handle == NULL) {
22377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22378                 }
22379                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22380                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22381                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22382                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22383         }
22384         if (flags & NDR_OUT) {
22385                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22386         }
22387         return NDR_ERR_SUCCESS;
22388 }
22389
22390 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
22391 {
22392         TALLOC_CTX *_mem_save_handle_0;
22393         if (flags & NDR_IN) {
22394                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22395                         NDR_PULL_ALLOC(ndr, r->in.handle);
22396                 }
22397                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22398                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22399                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22400                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22401                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22402                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22403                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22404         }
22405         if (flags & NDR_OUT) {
22406                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22407         }
22408         return NDR_ERR_SUCCESS;
22409 }
22410
22411 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
22412 {
22413         ndr_print_struct(ndr, name, "spoolss_AddForm");
22414         ndr->depth++;
22415         if (flags & NDR_SET_VALUES) {
22416                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22417         }
22418         if (flags & NDR_IN) {
22419                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
22420                 ndr->depth++;
22421                 ndr_print_ptr(ndr, "handle", r->in.handle);
22422                 ndr->depth++;
22423                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22424                 ndr->depth--;
22425                 ndr_print_uint32(ndr, "level", r->in.level);
22426                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22427                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22428                 ndr->depth--;
22429         }
22430         if (flags & NDR_OUT) {
22431                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22432                 ndr->depth++;
22433                 ndr_print_WERROR(ndr, "result", r->out.result);
22434                 ndr->depth--;
22435         }
22436         ndr->depth--;
22437 }
22438
22439 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22440 {
22441         if (flags & NDR_IN) {
22442                 if (r->in.handle == NULL) {
22443                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22444                 }
22445                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22447                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22449                 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));
22450         }
22451         if (flags & NDR_OUT) {
22452                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22453         }
22454         return NDR_ERR_SUCCESS;
22455 }
22456
22457 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22458 {
22459         TALLOC_CTX *_mem_save_handle_0;
22460         if (flags & NDR_IN) {
22461                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22462                         NDR_PULL_ALLOC(ndr, r->in.handle);
22463                 }
22464                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22465                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22466                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22468                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22469                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22470                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22471                         return 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));
22472                 }
22473                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22474                 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));
22475         }
22476         if (flags & NDR_OUT) {
22477                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22478         }
22479         return NDR_ERR_SUCCESS;
22480 }
22481
22482 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22483 {
22484         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22485         ndr->depth++;
22486         if (flags & NDR_SET_VALUES) {
22487                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22488         }
22489         if (flags & NDR_IN) {
22490                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22491                 ndr->depth++;
22492                 ndr_print_ptr(ndr, "handle", r->in.handle);
22493                 ndr->depth++;
22494                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22495                 ndr->depth--;
22496                 ndr_print_string(ndr, "form_name", r->in.form_name);
22497                 ndr->depth--;
22498         }
22499         if (flags & NDR_OUT) {
22500                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22501                 ndr->depth++;
22502                 ndr_print_WERROR(ndr, "result", r->out.result);
22503                 ndr->depth--;
22504         }
22505         ndr->depth--;
22506 }
22507
22508 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22509 {
22510         if (flags & NDR_IN) {
22511                 if (r->in.handle == NULL) {
22512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22513                 }
22514                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22518                 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));
22519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22521                 if (r->in.buffer) {
22522                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22523                 }
22524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22525         }
22526         if (flags & NDR_OUT) {
22527                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22528                 if (r->out.info) {
22529                         {
22530                                 struct ndr_push *_ndr_info;
22531                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22532                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22533                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22534                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22535                         }
22536                 }
22537                 if (r->out.needed == NULL) {
22538                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22539                 }
22540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22541                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22542         }
22543         return NDR_ERR_SUCCESS;
22544 }
22545
22546 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22547 {
22548         uint32_t _ptr_buffer;
22549         uint32_t _ptr_info;
22550         TALLOC_CTX *_mem_save_handle_0;
22551         TALLOC_CTX *_mem_save_buffer_0;
22552         TALLOC_CTX *_mem_save_info_0;
22553         TALLOC_CTX *_mem_save_needed_0;
22554         if (flags & NDR_IN) {
22555                 ZERO_STRUCT(r->out);
22556
22557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22558                         NDR_PULL_ALLOC(ndr, r->in.handle);
22559                 }
22560                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22564                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22565                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22566                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22567                         return 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));
22568                 }
22569                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22570                 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));
22571                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22573                 if (_ptr_buffer) {
22574                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22575                 } else {
22576                         r->in.buffer = NULL;
22577                 }
22578                 if (r->in.buffer) {
22579                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22580                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22581                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22582                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22583                 }
22584                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22585                 NDR_PULL_ALLOC(ndr, r->out.needed);
22586                 ZERO_STRUCTP(r->out.needed);
22587         }
22588         if (flags & NDR_OUT) {
22589                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22590                 if (_ptr_info) {
22591                         NDR_PULL_ALLOC(ndr, r->out.info);
22592                 } else {
22593                         r->out.info = NULL;
22594                 }
22595                 if (r->out.info) {
22596                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22597                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22598                         {
22599                                 struct ndr_pull *_ndr_info;
22600                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22601                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22602                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22603                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22604                         }
22605                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22606                 }
22607                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22608                         NDR_PULL_ALLOC(ndr, r->out.needed);
22609                 }
22610                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22611                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22612                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22613                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22614                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22615         }
22616         return NDR_ERR_SUCCESS;
22617 }
22618
22619 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22620 {
22621         ndr_print_struct(ndr, name, "spoolss_GetForm");
22622         ndr->depth++;
22623         if (flags & NDR_SET_VALUES) {
22624                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22625         }
22626         if (flags & NDR_IN) {
22627                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22628                 ndr->depth++;
22629                 ndr_print_ptr(ndr, "handle", r->in.handle);
22630                 ndr->depth++;
22631                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22632                 ndr->depth--;
22633                 ndr_print_string(ndr, "form_name", r->in.form_name);
22634                 ndr_print_uint32(ndr, "level", r->in.level);
22635                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22636                 ndr->depth++;
22637                 if (r->in.buffer) {
22638                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22639                 }
22640                 ndr->depth--;
22641                 ndr_print_uint32(ndr, "offered", r->in.offered);
22642                 ndr->depth--;
22643         }
22644         if (flags & NDR_OUT) {
22645                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22646                 ndr->depth++;
22647                 ndr_print_ptr(ndr, "info", r->out.info);
22648                 ndr->depth++;
22649                 if (r->out.info) {
22650                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22651                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22652                 }
22653                 ndr->depth--;
22654                 ndr_print_ptr(ndr, "needed", r->out.needed);
22655                 ndr->depth++;
22656                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22657                 ndr->depth--;
22658                 ndr_print_WERROR(ndr, "result", r->out.result);
22659                 ndr->depth--;
22660         }
22661         ndr->depth--;
22662 }
22663
22664 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22665 {
22666         if (flags & NDR_IN) {
22667                 if (r->in.handle == NULL) {
22668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22669                 }
22670                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22671                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22672                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22674                 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));
22675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22676                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22677                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22678         }
22679         if (flags & NDR_OUT) {
22680                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22681         }
22682         return NDR_ERR_SUCCESS;
22683 }
22684
22685 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22686 {
22687         TALLOC_CTX *_mem_save_handle_0;
22688         if (flags & NDR_IN) {
22689                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22690                         NDR_PULL_ALLOC(ndr, r->in.handle);
22691                 }
22692                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22693                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22694                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22695                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22696                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22697                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22698                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22699                         return 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));
22700                 }
22701                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22702                 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));
22703                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22704                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22705                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22706         }
22707         if (flags & NDR_OUT) {
22708                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22709         }
22710         return NDR_ERR_SUCCESS;
22711 }
22712
22713 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22714 {
22715         ndr_print_struct(ndr, name, "spoolss_SetForm");
22716         ndr->depth++;
22717         if (flags & NDR_SET_VALUES) {
22718                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22719         }
22720         if (flags & NDR_IN) {
22721                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22722                 ndr->depth++;
22723                 ndr_print_ptr(ndr, "handle", r->in.handle);
22724                 ndr->depth++;
22725                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22726                 ndr->depth--;
22727                 ndr_print_string(ndr, "form_name", r->in.form_name);
22728                 ndr_print_uint32(ndr, "level", r->in.level);
22729                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22730                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22731                 ndr->depth--;
22732         }
22733         if (flags & NDR_OUT) {
22734                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22735                 ndr->depth++;
22736                 ndr_print_WERROR(ndr, "result", r->out.result);
22737                 ndr->depth--;
22738         }
22739         ndr->depth--;
22740 }
22741
22742 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22743 {
22744         if (flags & NDR_IN) {
22745                 if (r->in.handle == NULL) {
22746                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22747                 }
22748                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22750                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22751                 if (r->in.buffer) {
22752                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22753                 }
22754                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22755         }
22756         if (flags & NDR_OUT) {
22757                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22758                 if (r->out.info) {
22759                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22760                 }
22761                 if (r->out.needed == NULL) {
22762                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22763                 }
22764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22765                 if (r->out.count == NULL) {
22766                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22767                 }
22768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22769                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22770         }
22771         return NDR_ERR_SUCCESS;
22772 }
22773
22774 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22775 {
22776         uint32_t _ptr_buffer;
22777         uint32_t _ptr_info;
22778         TALLOC_CTX *_mem_save_handle_0;
22779         TALLOC_CTX *_mem_save_buffer_0;
22780         TALLOC_CTX *_mem_save_info_0;
22781         TALLOC_CTX *_mem_save_needed_0;
22782         TALLOC_CTX *_mem_save_count_0;
22783         if (flags & NDR_IN) {
22784                 ZERO_STRUCT(r->out);
22785
22786                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22787                         NDR_PULL_ALLOC(ndr, r->in.handle);
22788                 }
22789                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22790                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22791                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22792                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22793                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22794                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22795                 if (_ptr_buffer) {
22796                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22797                 } else {
22798                         r->in.buffer = NULL;
22799                 }
22800                 if (r->in.buffer) {
22801                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22802                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22803                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22804                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22805                 }
22806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22807                 NDR_PULL_ALLOC(ndr, r->out.needed);
22808                 ZERO_STRUCTP(r->out.needed);
22809                 NDR_PULL_ALLOC(ndr, r->out.count);
22810                 ZERO_STRUCTP(r->out.count);
22811         }
22812         if (flags & NDR_OUT) {
22813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22814                 if (_ptr_info) {
22815                         NDR_PULL_ALLOC(ndr, r->out.info);
22816                 } else {
22817                         r->out.info = NULL;
22818                 }
22819                 if (r->out.info) {
22820                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22821                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22822                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22824                 }
22825                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22826                         NDR_PULL_ALLOC(ndr, r->out.needed);
22827                 }
22828                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22829                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22831                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22832                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22833                         NDR_PULL_ALLOC(ndr, r->out.count);
22834                 }
22835                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22836                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22837                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22838                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22839                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22840         }
22841         return NDR_ERR_SUCCESS;
22842 }
22843
22844 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22845 {
22846         uint32_t cntr_info_0;
22847         if (flags & NDR_IN) {
22848                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22849                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22850         }
22851         if (flags & NDR_OUT) {
22852                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22853                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22854                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22855                 }
22856                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22857                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22858                 }
22859         }
22860         return NDR_ERR_SUCCESS;
22861 }
22862
22863 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22864 {
22865         uint32_t cntr_info_0;
22866         TALLOC_CTX *_mem_save_info_0;
22867         if (flags & NDR_IN) {
22868                 ZERO_STRUCT(r->out);
22869
22870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22872         }
22873         if (flags & NDR_OUT) {
22874                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22875                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22876                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22877                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22878                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22879                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22880                 }
22881                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22882                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22883                 }
22884                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22885         }
22886         return NDR_ERR_SUCCESS;
22887 }
22888
22889 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22890 {
22891         uint32_t cntr_info_2;
22892         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22893         ndr->depth++;
22894         if (flags & NDR_SET_VALUES) {
22895                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22896         }
22897         if (flags & NDR_IN) {
22898                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22899                 ndr->depth++;
22900                 ndr_print_ptr(ndr, "handle", r->in.handle);
22901                 ndr->depth++;
22902                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22903                 ndr->depth--;
22904                 ndr_print_uint32(ndr, "level", r->in.level);
22905                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22906                 ndr->depth++;
22907                 if (r->in.buffer) {
22908                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22909                 }
22910                 ndr->depth--;
22911                 ndr_print_uint32(ndr, "offered", r->in.offered);
22912                 ndr->depth--;
22913         }
22914         if (flags & NDR_OUT) {
22915                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22916                 ndr->depth++;
22917                 ndr_print_ptr(ndr, "count", r->out.count);
22918                 ndr->depth++;
22919                 ndr_print_uint32(ndr, "count", *r->out.count);
22920                 ndr->depth--;
22921                 ndr_print_ptr(ndr, "info", r->out.info);
22922                 ndr->depth++;
22923                 ndr_print_ptr(ndr, "info", *r->out.info);
22924                 ndr->depth++;
22925                 if (*r->out.info) {
22926                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22927                         ndr->depth++;
22928                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22929                                 char *idx_2=NULL;
22930                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22931                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22932                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22933                                         free(idx_2);
22934                                 }
22935                         }
22936                         ndr->depth--;
22937                 }
22938                 ndr->depth--;
22939                 ndr->depth--;
22940                 ndr_print_ptr(ndr, "needed", r->out.needed);
22941                 ndr->depth++;
22942                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22943                 ndr->depth--;
22944                 ndr_print_WERROR(ndr, "result", r->out.result);
22945                 ndr->depth--;
22946         }
22947         ndr->depth--;
22948 }
22949
22950 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22951 {
22952         if (flags & NDR_IN) {
22953                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22954                 if (r->in.servername) {
22955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22958                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22959                 }
22960                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22961                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22962                 if (r->in.buffer) {
22963                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22964                 }
22965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22966         }
22967         if (flags & NDR_OUT) {
22968                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22969                 if (r->out.info) {
22970                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22971                 }
22972                 if (r->out.needed == NULL) {
22973                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22974                 }
22975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22976                 if (r->out.count == NULL) {
22977                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22978                 }
22979                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22980                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22981         }
22982         return NDR_ERR_SUCCESS;
22983 }
22984
22985 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22986 {
22987         uint32_t _ptr_servername;
22988         uint32_t _ptr_buffer;
22989         uint32_t _ptr_info;
22990         TALLOC_CTX *_mem_save_servername_0;
22991         TALLOC_CTX *_mem_save_buffer_0;
22992         TALLOC_CTX *_mem_save_info_0;
22993         TALLOC_CTX *_mem_save_needed_0;
22994         TALLOC_CTX *_mem_save_count_0;
22995         if (flags & NDR_IN) {
22996                 ZERO_STRUCT(r->out);
22997
22998                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22999                 if (_ptr_servername) {
23000                         NDR_PULL_ALLOC(ndr, r->in.servername);
23001                 } else {
23002                         r->in.servername = NULL;
23003                 }
23004                 if (r->in.servername) {
23005                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23006                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23007                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23008                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23009                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23010                                 return 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));
23011                         }
23012                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23013                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23014                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23015                 }
23016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23017                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23018                 if (_ptr_buffer) {
23019                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23020                 } else {
23021                         r->in.buffer = NULL;
23022                 }
23023                 if (r->in.buffer) {
23024                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23025                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23026                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23027                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23028                 }
23029                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23030                 NDR_PULL_ALLOC(ndr, r->out.needed);
23031                 ZERO_STRUCTP(r->out.needed);
23032                 NDR_PULL_ALLOC(ndr, r->out.count);
23033                 ZERO_STRUCTP(r->out.count);
23034         }
23035         if (flags & NDR_OUT) {
23036                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23037                 if (_ptr_info) {
23038                         NDR_PULL_ALLOC(ndr, r->out.info);
23039                 } else {
23040                         r->out.info = NULL;
23041                 }
23042                 if (r->out.info) {
23043                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23044                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23045                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23047                 }
23048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23049                         NDR_PULL_ALLOC(ndr, r->out.needed);
23050                 }
23051                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23052                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23056                         NDR_PULL_ALLOC(ndr, r->out.count);
23057                 }
23058                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23059                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23060                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23062                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23063         }
23064         return NDR_ERR_SUCCESS;
23065 }
23066
23067 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
23068 {
23069         uint32_t cntr_info_0;
23070         if (flags & NDR_IN) {
23071                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23073         }
23074         if (flags & NDR_OUT) {
23075                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23076                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23077                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23078                 }
23079                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23080                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23081                 }
23082         }
23083         return NDR_ERR_SUCCESS;
23084 }
23085
23086 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
23087 {
23088         uint32_t cntr_info_0;
23089         TALLOC_CTX *_mem_save_info_0;
23090         if (flags & NDR_IN) {
23091                 ZERO_STRUCT(r->out);
23092
23093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23095         }
23096         if (flags & NDR_OUT) {
23097                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23098                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23099                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23100                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23101                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23102                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23103                 }
23104                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23105                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23106                 }
23107                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23108         }
23109         return NDR_ERR_SUCCESS;
23110 }
23111
23112 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
23113 {
23114         uint32_t cntr_info_2;
23115         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
23116         ndr->depth++;
23117         if (flags & NDR_SET_VALUES) {
23118                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23119         }
23120         if (flags & NDR_IN) {
23121                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
23122                 ndr->depth++;
23123                 ndr_print_ptr(ndr, "servername", r->in.servername);
23124                 ndr->depth++;
23125                 if (r->in.servername) {
23126                         ndr_print_string(ndr, "servername", r->in.servername);
23127                 }
23128                 ndr->depth--;
23129                 ndr_print_uint32(ndr, "level", r->in.level);
23130                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23131                 ndr->depth++;
23132                 if (r->in.buffer) {
23133                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23134                 }
23135                 ndr->depth--;
23136                 ndr_print_uint32(ndr, "offered", r->in.offered);
23137                 ndr->depth--;
23138         }
23139         if (flags & NDR_OUT) {
23140                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
23141                 ndr->depth++;
23142                 ndr_print_ptr(ndr, "count", r->out.count);
23143                 ndr->depth++;
23144                 ndr_print_uint32(ndr, "count", *r->out.count);
23145                 ndr->depth--;
23146                 ndr_print_ptr(ndr, "info", r->out.info);
23147                 ndr->depth++;
23148                 ndr_print_ptr(ndr, "info", *r->out.info);
23149                 ndr->depth++;
23150                 if (*r->out.info) {
23151                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23152                         ndr->depth++;
23153                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23154                                 char *idx_2=NULL;
23155                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23156                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23157                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23158                                         free(idx_2);
23159                                 }
23160                         }
23161                         ndr->depth--;
23162                 }
23163                 ndr->depth--;
23164                 ndr->depth--;
23165                 ndr_print_ptr(ndr, "needed", r->out.needed);
23166                 ndr->depth++;
23167                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23168                 ndr->depth--;
23169                 ndr_print_WERROR(ndr, "result", r->out.result);
23170                 ndr->depth--;
23171         }
23172         ndr->depth--;
23173 }
23174
23175 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
23176 {
23177         if (flags & NDR_IN) {
23178                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23179                 if (r->in.servername) {
23180                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23181                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23182                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23183                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23184                 }
23185                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23186                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23187                 if (r->in.buffer) {
23188                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23189                 }
23190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23191         }
23192         if (flags & NDR_OUT) {
23193                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23194                 if (r->out.info) {
23195                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23196                 }
23197                 if (r->out.needed == NULL) {
23198                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23199                 }
23200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23201                 if (r->out.count == NULL) {
23202                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23203                 }
23204                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23205                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23206         }
23207         return NDR_ERR_SUCCESS;
23208 }
23209
23210 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
23211 {
23212         uint32_t _ptr_servername;
23213         uint32_t _ptr_buffer;
23214         uint32_t _ptr_info;
23215         TALLOC_CTX *_mem_save_servername_0;
23216         TALLOC_CTX *_mem_save_buffer_0;
23217         TALLOC_CTX *_mem_save_info_0;
23218         TALLOC_CTX *_mem_save_needed_0;
23219         TALLOC_CTX *_mem_save_count_0;
23220         if (flags & NDR_IN) {
23221                 ZERO_STRUCT(r->out);
23222
23223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23224                 if (_ptr_servername) {
23225                         NDR_PULL_ALLOC(ndr, r->in.servername);
23226                 } else {
23227                         r->in.servername = NULL;
23228                 }
23229                 if (r->in.servername) {
23230                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23231                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23234                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23235                                 return 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));
23236                         }
23237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23240                 }
23241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23243                 if (_ptr_buffer) {
23244                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23245                 } else {
23246                         r->in.buffer = NULL;
23247                 }
23248                 if (r->in.buffer) {
23249                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23250                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23251                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23253                 }
23254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23255                 NDR_PULL_ALLOC(ndr, r->out.needed);
23256                 ZERO_STRUCTP(r->out.needed);
23257                 NDR_PULL_ALLOC(ndr, r->out.count);
23258                 ZERO_STRUCTP(r->out.count);
23259         }
23260         if (flags & NDR_OUT) {
23261                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23262                 if (_ptr_info) {
23263                         NDR_PULL_ALLOC(ndr, r->out.info);
23264                 } else {
23265                         r->out.info = NULL;
23266                 }
23267                 if (r->out.info) {
23268                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23269                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23270                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23271                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23272                 }
23273                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23274                         NDR_PULL_ALLOC(ndr, r->out.needed);
23275                 }
23276                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23277                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23278                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23279                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23280                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23281                         NDR_PULL_ALLOC(ndr, r->out.count);
23282                 }
23283                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23284                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23286                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23287                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23288         }
23289         return NDR_ERR_SUCCESS;
23290 }
23291
23292 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
23293 {
23294         uint32_t cntr_info_0;
23295         if (flags & NDR_IN) {
23296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23298         }
23299         if (flags & NDR_OUT) {
23300                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23301                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23302                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23303                 }
23304                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23305                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23306                 }
23307         }
23308         return NDR_ERR_SUCCESS;
23309 }
23310
23311 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
23312 {
23313         uint32_t cntr_info_0;
23314         TALLOC_CTX *_mem_save_info_0;
23315         if (flags & NDR_IN) {
23316                 ZERO_STRUCT(r->out);
23317
23318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23320         }
23321         if (flags & NDR_OUT) {
23322                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23323                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23324                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23325                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23326                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23327                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23328                 }
23329                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23330                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23331                 }
23332                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23333         }
23334         return NDR_ERR_SUCCESS;
23335 }
23336
23337 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
23338 {
23339         uint32_t cntr_info_2;
23340         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
23341         ndr->depth++;
23342         if (flags & NDR_SET_VALUES) {
23343                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23344         }
23345         if (flags & NDR_IN) {
23346                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
23347                 ndr->depth++;
23348                 ndr_print_ptr(ndr, "servername", r->in.servername);
23349                 ndr->depth++;
23350                 if (r->in.servername) {
23351                         ndr_print_string(ndr, "servername", r->in.servername);
23352                 }
23353                 ndr->depth--;
23354                 ndr_print_uint32(ndr, "level", r->in.level);
23355                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23356                 ndr->depth++;
23357                 if (r->in.buffer) {
23358                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23359                 }
23360                 ndr->depth--;
23361                 ndr_print_uint32(ndr, "offered", r->in.offered);
23362                 ndr->depth--;
23363         }
23364         if (flags & NDR_OUT) {
23365                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
23366                 ndr->depth++;
23367                 ndr_print_ptr(ndr, "count", r->out.count);
23368                 ndr->depth++;
23369                 ndr_print_uint32(ndr, "count", *r->out.count);
23370                 ndr->depth--;
23371                 ndr_print_ptr(ndr, "info", r->out.info);
23372                 ndr->depth++;
23373                 ndr_print_ptr(ndr, "info", *r->out.info);
23374                 ndr->depth++;
23375                 if (*r->out.info) {
23376                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23377                         ndr->depth++;
23378                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23379                                 char *idx_2=NULL;
23380                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23381                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23382                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23383                                         free(idx_2);
23384                                 }
23385                         }
23386                         ndr->depth--;
23387                 }
23388                 ndr->depth--;
23389                 ndr->depth--;
23390                 ndr_print_ptr(ndr, "needed", r->out.needed);
23391                 ndr->depth++;
23392                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23393                 ndr->depth--;
23394                 ndr_print_WERROR(ndr, "result", r->out.result);
23395                 ndr->depth--;
23396         }
23397         ndr->depth--;
23398 }
23399
23400 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
23401 {
23402         if (flags & NDR_IN) {
23403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
23404                 if (r->in.server_name) {
23405                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23406                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23408                         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));
23409                 }
23410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
23411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23414                 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));
23415         }
23416         if (flags & NDR_OUT) {
23417                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23418         }
23419         return NDR_ERR_SUCCESS;
23420 }
23421
23422 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23423 {
23424         uint32_t _ptr_server_name;
23425         TALLOC_CTX *_mem_save_server_name_0;
23426         if (flags & NDR_IN) {
23427                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23428                 if (_ptr_server_name) {
23429                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23430                 } else {
23431                         r->in.server_name = NULL;
23432                 }
23433                 if (r->in.server_name) {
23434                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23435                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23436                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23437                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23438                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23439                                 return 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));
23440                         }
23441                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23442                         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));
23443                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23444                 }
23445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23446                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23447                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23448                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23449                         return 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));
23450                 }
23451                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23452                 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));
23453         }
23454         if (flags & NDR_OUT) {
23455                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23456         }
23457         return NDR_ERR_SUCCESS;
23458 }
23459
23460 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23461 {
23462         ndr_print_struct(ndr, name, "spoolss_AddPort");
23463         ndr->depth++;
23464         if (flags & NDR_SET_VALUES) {
23465                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23466         }
23467         if (flags & NDR_IN) {
23468                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23469                 ndr->depth++;
23470                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23471                 ndr->depth++;
23472                 if (r->in.server_name) {
23473                         ndr_print_string(ndr, "server_name", r->in.server_name);
23474                 }
23475                 ndr->depth--;
23476                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23477                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23478                 ndr->depth--;
23479         }
23480         if (flags & NDR_OUT) {
23481                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23482                 ndr->depth++;
23483                 ndr_print_WERROR(ndr, "result", r->out.result);
23484                 ndr->depth--;
23485         }
23486         ndr->depth--;
23487 }
23488
23489 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23490 {
23491         if (flags & NDR_IN) {
23492         }
23493         if (flags & NDR_OUT) {
23494                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23495         }
23496         return NDR_ERR_SUCCESS;
23497 }
23498
23499 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23500 {
23501         if (flags & NDR_IN) {
23502         }
23503         if (flags & NDR_OUT) {
23504                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23505         }
23506         return NDR_ERR_SUCCESS;
23507 }
23508
23509 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23510 {
23511         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23512         ndr->depth++;
23513         if (flags & NDR_SET_VALUES) {
23514                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23515         }
23516         if (flags & NDR_IN) {
23517                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23518                 ndr->depth++;
23519                 ndr->depth--;
23520         }
23521         if (flags & NDR_OUT) {
23522                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23523                 ndr->depth++;
23524                 ndr_print_WERROR(ndr, "result", r->out.result);
23525                 ndr->depth--;
23526         }
23527         ndr->depth--;
23528 }
23529
23530 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23531 {
23532         if (flags & NDR_IN) {
23533         }
23534         if (flags & NDR_OUT) {
23535                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23536         }
23537         return NDR_ERR_SUCCESS;
23538 }
23539
23540 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23541 {
23542         if (flags & NDR_IN) {
23543         }
23544         if (flags & NDR_OUT) {
23545                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23546         }
23547         return NDR_ERR_SUCCESS;
23548 }
23549
23550 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23551 {
23552         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23553         ndr->depth++;
23554         if (flags & NDR_SET_VALUES) {
23555                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23556         }
23557         if (flags & NDR_IN) {
23558                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23559                 ndr->depth++;
23560                 ndr->depth--;
23561         }
23562         if (flags & NDR_OUT) {
23563                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23564                 ndr->depth++;
23565                 ndr_print_WERROR(ndr, "result", r->out.result);
23566                 ndr->depth--;
23567         }
23568         ndr->depth--;
23569 }
23570
23571 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23572 {
23573         if (flags & NDR_IN) {
23574         }
23575         if (flags & NDR_OUT) {
23576                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23577         }
23578         return NDR_ERR_SUCCESS;
23579 }
23580
23581 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23582 {
23583         if (flags & NDR_IN) {
23584         }
23585         if (flags & NDR_OUT) {
23586                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23587         }
23588         return NDR_ERR_SUCCESS;
23589 }
23590
23591 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23592 {
23593         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23594         ndr->depth++;
23595         if (flags & NDR_SET_VALUES) {
23596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23597         }
23598         if (flags & NDR_IN) {
23599                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23600                 ndr->depth++;
23601                 ndr->depth--;
23602         }
23603         if (flags & NDR_OUT) {
23604                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23605                 ndr->depth++;
23606                 ndr_print_WERROR(ndr, "result", r->out.result);
23607                 ndr->depth--;
23608         }
23609         ndr->depth--;
23610 }
23611
23612 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23613 {
23614         if (flags & NDR_IN) {
23615         }
23616         if (flags & NDR_OUT) {
23617                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23618         }
23619         return NDR_ERR_SUCCESS;
23620 }
23621
23622 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23623 {
23624         if (flags & NDR_IN) {
23625         }
23626         if (flags & NDR_OUT) {
23627                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23628         }
23629         return NDR_ERR_SUCCESS;
23630 }
23631
23632 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23633 {
23634         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23635         ndr->depth++;
23636         if (flags & NDR_SET_VALUES) {
23637                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23638         }
23639         if (flags & NDR_IN) {
23640                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23641                 ndr->depth++;
23642                 ndr->depth--;
23643         }
23644         if (flags & NDR_OUT) {
23645                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23646                 ndr->depth++;
23647                 ndr_print_WERROR(ndr, "result", r->out.result);
23648                 ndr->depth--;
23649         }
23650         ndr->depth--;
23651 }
23652
23653 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23654 {
23655         if (flags & NDR_IN) {
23656         }
23657         if (flags & NDR_OUT) {
23658                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23659         }
23660         return NDR_ERR_SUCCESS;
23661 }
23662
23663 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23664 {
23665         if (flags & NDR_IN) {
23666         }
23667         if (flags & NDR_OUT) {
23668                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23669         }
23670         return NDR_ERR_SUCCESS;
23671 }
23672
23673 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23674 {
23675         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23676         ndr->depth++;
23677         if (flags & NDR_SET_VALUES) {
23678                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23679         }
23680         if (flags & NDR_IN) {
23681                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23682                 ndr->depth++;
23683                 ndr->depth--;
23684         }
23685         if (flags & NDR_OUT) {
23686                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23687                 ndr->depth++;
23688                 ndr_print_WERROR(ndr, "result", r->out.result);
23689                 ndr->depth--;
23690         }
23691         ndr->depth--;
23692 }
23693
23694 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23695 {
23696         if (flags & NDR_IN) {
23697         }
23698         if (flags & NDR_OUT) {
23699                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23700         }
23701         return NDR_ERR_SUCCESS;
23702 }
23703
23704 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23705 {
23706         if (flags & NDR_IN) {
23707         }
23708         if (flags & NDR_OUT) {
23709                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23710         }
23711         return NDR_ERR_SUCCESS;
23712 }
23713
23714 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23715 {
23716         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23717         ndr->depth++;
23718         if (flags & NDR_SET_VALUES) {
23719                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23720         }
23721         if (flags & NDR_IN) {
23722                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23723                 ndr->depth++;
23724                 ndr->depth--;
23725         }
23726         if (flags & NDR_OUT) {
23727                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23728                 ndr->depth++;
23729                 ndr_print_WERROR(ndr, "result", r->out.result);
23730                 ndr->depth--;
23731         }
23732         ndr->depth--;
23733 }
23734
23735 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23736 {
23737         if (flags & NDR_IN) {
23738         }
23739         if (flags & NDR_OUT) {
23740                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23741         }
23742         return NDR_ERR_SUCCESS;
23743 }
23744
23745 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23746 {
23747         if (flags & NDR_IN) {
23748         }
23749         if (flags & NDR_OUT) {
23750                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23751         }
23752         return NDR_ERR_SUCCESS;
23753 }
23754
23755 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23756 {
23757         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23758         ndr->depth++;
23759         if (flags & NDR_SET_VALUES) {
23760                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23761         }
23762         if (flags & NDR_IN) {
23763                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23764                 ndr->depth++;
23765                 ndr->depth--;
23766         }
23767         if (flags & NDR_OUT) {
23768                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23769                 ndr->depth++;
23770                 ndr_print_WERROR(ndr, "result", r->out.result);
23771                 ndr->depth--;
23772         }
23773         ndr->depth--;
23774 }
23775
23776 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23777 {
23778         if (flags & NDR_IN) {
23779         }
23780         if (flags & NDR_OUT) {
23781                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23782         }
23783         return NDR_ERR_SUCCESS;
23784 }
23785
23786 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23787 {
23788         if (flags & NDR_IN) {
23789         }
23790         if (flags & NDR_OUT) {
23791                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23792         }
23793         return NDR_ERR_SUCCESS;
23794 }
23795
23796 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23797 {
23798         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23799         ndr->depth++;
23800         if (flags & NDR_SET_VALUES) {
23801                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23802         }
23803         if (flags & NDR_IN) {
23804                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23805                 ndr->depth++;
23806                 ndr->depth--;
23807         }
23808         if (flags & NDR_OUT) {
23809                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23810                 ndr->depth++;
23811                 ndr_print_WERROR(ndr, "result", r->out.result);
23812                 ndr->depth--;
23813         }
23814         ndr->depth--;
23815 }
23816
23817 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23818 {
23819         if (flags & NDR_IN) {
23820         }
23821         if (flags & NDR_OUT) {
23822                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23823         }
23824         return NDR_ERR_SUCCESS;
23825 }
23826
23827 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23828 {
23829         if (flags & NDR_IN) {
23830         }
23831         if (flags & NDR_OUT) {
23832                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23833         }
23834         return NDR_ERR_SUCCESS;
23835 }
23836
23837 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23838 {
23839         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23840         ndr->depth++;
23841         if (flags & NDR_SET_VALUES) {
23842                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23843         }
23844         if (flags & NDR_IN) {
23845                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23846                 ndr->depth++;
23847                 ndr->depth--;
23848         }
23849         if (flags & NDR_OUT) {
23850                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23851                 ndr->depth++;
23852                 ndr_print_WERROR(ndr, "result", r->out.result);
23853                 ndr->depth--;
23854         }
23855         ndr->depth--;
23856 }
23857
23858 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23859 {
23860         if (flags & NDR_IN) {
23861         }
23862         if (flags & NDR_OUT) {
23863                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23864         }
23865         return NDR_ERR_SUCCESS;
23866 }
23867
23868 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23869 {
23870         if (flags & NDR_IN) {
23871         }
23872         if (flags & NDR_OUT) {
23873                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23874         }
23875         return NDR_ERR_SUCCESS;
23876 }
23877
23878 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23879 {
23880         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23881         ndr->depth++;
23882         if (flags & NDR_SET_VALUES) {
23883                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23884         }
23885         if (flags & NDR_IN) {
23886                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23887                 ndr->depth++;
23888                 ndr->depth--;
23889         }
23890         if (flags & NDR_OUT) {
23891                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23892                 ndr->depth++;
23893                 ndr_print_WERROR(ndr, "result", r->out.result);
23894                 ndr->depth--;
23895         }
23896         ndr->depth--;
23897 }
23898
23899 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23900 {
23901         if (flags & NDR_IN) {
23902         }
23903         if (flags & NDR_OUT) {
23904                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23905         }
23906         return NDR_ERR_SUCCESS;
23907 }
23908
23909 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23910 {
23911         if (flags & NDR_IN) {
23912         }
23913         if (flags & NDR_OUT) {
23914                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23915         }
23916         return NDR_ERR_SUCCESS;
23917 }
23918
23919 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23920 {
23921         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23922         ndr->depth++;
23923         if (flags & NDR_SET_VALUES) {
23924                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23925         }
23926         if (flags & NDR_IN) {
23927                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23928                 ndr->depth++;
23929                 ndr->depth--;
23930         }
23931         if (flags & NDR_OUT) {
23932                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23933                 ndr->depth++;
23934                 ndr_print_WERROR(ndr, "result", r->out.result);
23935                 ndr->depth--;
23936         }
23937         ndr->depth--;
23938 }
23939
23940 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23941 {
23942         if (flags & NDR_IN) {
23943         }
23944         if (flags & NDR_OUT) {
23945                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23946         }
23947         return NDR_ERR_SUCCESS;
23948 }
23949
23950 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23951 {
23952         if (flags & NDR_IN) {
23953         }
23954         if (flags & NDR_OUT) {
23955                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23956         }
23957         return NDR_ERR_SUCCESS;
23958 }
23959
23960 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23961 {
23962         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23963         ndr->depth++;
23964         if (flags & NDR_SET_VALUES) {
23965                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23966         }
23967         if (flags & NDR_IN) {
23968                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23969                 ndr->depth++;
23970                 ndr->depth--;
23971         }
23972         if (flags & NDR_OUT) {
23973                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23974                 ndr->depth++;
23975                 ndr_print_WERROR(ndr, "result", r->out.result);
23976                 ndr->depth--;
23977         }
23978         ndr->depth--;
23979 }
23980
23981 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23982 {
23983         if (flags & NDR_IN) {
23984         }
23985         if (flags & NDR_OUT) {
23986                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23987         }
23988         return NDR_ERR_SUCCESS;
23989 }
23990
23991 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23992 {
23993         if (flags & NDR_IN) {
23994         }
23995         if (flags & NDR_OUT) {
23996                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23997         }
23998         return NDR_ERR_SUCCESS;
23999 }
24000
24001 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
24002 {
24003         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
24004         ndr->depth++;
24005         if (flags & NDR_SET_VALUES) {
24006                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24007         }
24008         if (flags & NDR_IN) {
24009                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
24010                 ndr->depth++;
24011                 ndr->depth--;
24012         }
24013         if (flags & NDR_OUT) {
24014                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
24015                 ndr->depth++;
24016                 ndr_print_WERROR(ndr, "result", r->out.result);
24017                 ndr->depth--;
24018         }
24019         ndr->depth--;
24020 }
24021
24022 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
24023 {
24024         if (flags & NDR_IN) {
24025                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
24026                 if (r->in.servername) {
24027                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24028                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24029                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
24030                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24031                 }
24032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
24033                 if (r->in.print_processor_name) {
24034                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24035                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24036                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
24037                         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));
24038                 }
24039                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24040                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24041                 if (r->in.buffer) {
24042                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24043                 }
24044                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24045         }
24046         if (flags & NDR_OUT) {
24047                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24048                 if (r->out.info) {
24049                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
24050                 }
24051                 if (r->out.needed == NULL) {
24052                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24053                 }
24054                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24055                 if (r->out.count == NULL) {
24056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24057                 }
24058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
24059                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24060         }
24061         return NDR_ERR_SUCCESS;
24062 }
24063
24064 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
24065 {
24066         uint32_t _ptr_servername;
24067         uint32_t _ptr_print_processor_name;
24068         uint32_t _ptr_buffer;
24069         uint32_t _ptr_info;
24070         TALLOC_CTX *_mem_save_servername_0;
24071         TALLOC_CTX *_mem_save_print_processor_name_0;
24072         TALLOC_CTX *_mem_save_buffer_0;
24073         TALLOC_CTX *_mem_save_info_0;
24074         TALLOC_CTX *_mem_save_needed_0;
24075         TALLOC_CTX *_mem_save_count_0;
24076         if (flags & NDR_IN) {
24077                 ZERO_STRUCT(r->out);
24078
24079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
24080                 if (_ptr_servername) {
24081                         NDR_PULL_ALLOC(ndr, r->in.servername);
24082                 } else {
24083                         r->in.servername = NULL;
24084                 }
24085                 if (r->in.servername) {
24086                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
24087                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
24088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
24089                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
24090                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
24091                                 return 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));
24092                         }
24093                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
24094                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
24095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
24096                 }
24097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
24098                 if (_ptr_print_processor_name) {
24099                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
24100                 } else {
24101                         r->in.print_processor_name = NULL;
24102                 }
24103                 if (r->in.print_processor_name) {
24104                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
24105                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
24106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
24107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
24108                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
24109                                 return 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));
24110                         }
24111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
24112                         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));
24113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
24114                 }
24115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24117                 if (_ptr_buffer) {
24118                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24119                 } else {
24120                         r->in.buffer = NULL;
24121                 }
24122                 if (r->in.buffer) {
24123                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24124                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24125                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24126                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24127                 }
24128                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24129                 NDR_PULL_ALLOC(ndr, r->out.needed);
24130                 ZERO_STRUCTP(r->out.needed);
24131                 NDR_PULL_ALLOC(ndr, r->out.count);
24132                 ZERO_STRUCTP(r->out.count);
24133         }
24134         if (flags & NDR_OUT) {
24135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24136                 if (_ptr_info) {
24137                         NDR_PULL_ALLOC(ndr, r->out.info);
24138                 } else {
24139                         r->out.info = NULL;
24140                 }
24141                 if (r->out.info) {
24142                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24143                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24144                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24145                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24146                 }
24147                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24148                         NDR_PULL_ALLOC(ndr, r->out.needed);
24149                 }
24150                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24151                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24153                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24154                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24155                         NDR_PULL_ALLOC(ndr, r->out.count);
24156                 }
24157                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24158                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24160                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24161                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24162         }
24163         return NDR_ERR_SUCCESS;
24164 }
24165
24166 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
24167 {
24168         uint32_t cntr_info_0;
24169         if (flags & NDR_IN) {
24170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24172         }
24173         if (flags & NDR_OUT) {
24174                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24175                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24176                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24177                 }
24178                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24179                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24180                 }
24181         }
24182         return NDR_ERR_SUCCESS;
24183 }
24184
24185 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
24186 {
24187         uint32_t cntr_info_0;
24188         TALLOC_CTX *_mem_save_info_0;
24189         if (flags & NDR_IN) {
24190                 ZERO_STRUCT(r->out);
24191
24192                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24194         }
24195         if (flags & NDR_OUT) {
24196                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24197                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24198                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24199                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24200                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24201                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24202                 }
24203                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24204                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24205                 }
24206                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24207         }
24208         return NDR_ERR_SUCCESS;
24209 }
24210
24211 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
24212 {
24213         uint32_t cntr_info_2;
24214         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
24215         ndr->depth++;
24216         if (flags & NDR_SET_VALUES) {
24217                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24218         }
24219         if (flags & NDR_IN) {
24220                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
24221                 ndr->depth++;
24222                 ndr_print_ptr(ndr, "servername", r->in.servername);
24223                 ndr->depth++;
24224                 if (r->in.servername) {
24225                         ndr_print_string(ndr, "servername", r->in.servername);
24226                 }
24227                 ndr->depth--;
24228                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
24229                 ndr->depth++;
24230                 if (r->in.print_processor_name) {
24231                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
24232                 }
24233                 ndr->depth--;
24234                 ndr_print_uint32(ndr, "level", r->in.level);
24235                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24236                 ndr->depth++;
24237                 if (r->in.buffer) {
24238                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24239                 }
24240                 ndr->depth--;
24241                 ndr_print_uint32(ndr, "offered", r->in.offered);
24242                 ndr->depth--;
24243         }
24244         if (flags & NDR_OUT) {
24245                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
24246                 ndr->depth++;
24247                 ndr_print_ptr(ndr, "count", r->out.count);
24248                 ndr->depth++;
24249                 ndr_print_uint32(ndr, "count", *r->out.count);
24250                 ndr->depth--;
24251                 ndr_print_ptr(ndr, "info", r->out.info);
24252                 ndr->depth++;
24253                 ndr_print_ptr(ndr, "info", *r->out.info);
24254                 ndr->depth++;
24255                 if (*r->out.info) {
24256                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24257                         ndr->depth++;
24258                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24259                                 char *idx_2=NULL;
24260                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24261                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24262                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24263                                         free(idx_2);
24264                                 }
24265                         }
24266                         ndr->depth--;
24267                 }
24268                 ndr->depth--;
24269                 ndr->depth--;
24270                 ndr_print_ptr(ndr, "needed", r->out.needed);
24271                 ndr->depth++;
24272                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24273                 ndr->depth--;
24274                 ndr_print_WERROR(ndr, "result", r->out.result);
24275                 ndr->depth--;
24276         }
24277         ndr->depth--;
24278 }
24279
24280 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
24281 {
24282         if (flags & NDR_IN) {
24283                 if (r->in.handle == NULL) {
24284                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24285                 }
24286                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24287                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
24288                 if (r->in.data_type) {
24289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24290                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24292                         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));
24293                 }
24294                 if (r->in.devmode_ctr == NULL) {
24295                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24296                 }
24297                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24298         }
24299         if (flags & NDR_OUT) {
24300                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24301         }
24302         return NDR_ERR_SUCCESS;
24303 }
24304
24305 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
24306 {
24307         uint32_t _ptr_data_type;
24308         TALLOC_CTX *_mem_save_handle_0;
24309         TALLOC_CTX *_mem_save_data_type_0;
24310         TALLOC_CTX *_mem_save_devmode_ctr_0;
24311         if (flags & NDR_IN) {
24312                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24313                         NDR_PULL_ALLOC(ndr, r->in.handle);
24314                 }
24315                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24316                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24317                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24318                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24319                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
24320                 if (_ptr_data_type) {
24321                         NDR_PULL_ALLOC(ndr, r->in.data_type);
24322                 } else {
24323                         r->in.data_type = NULL;
24324                 }
24325                 if (r->in.data_type) {
24326                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24327                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
24328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
24329                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
24330                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
24331                                 return 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));
24332                         }
24333                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
24334                         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));
24335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
24336                 }
24337                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24338                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24339                 }
24340                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24341                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24342                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24343                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24344         }
24345         if (flags & NDR_OUT) {
24346                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24347         }
24348         return NDR_ERR_SUCCESS;
24349 }
24350
24351 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
24352 {
24353         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
24354         ndr->depth++;
24355         if (flags & NDR_SET_VALUES) {
24356                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24357         }
24358         if (flags & NDR_IN) {
24359                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
24360                 ndr->depth++;
24361                 ndr_print_ptr(ndr, "handle", r->in.handle);
24362                 ndr->depth++;
24363                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24364                 ndr->depth--;
24365                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
24366                 ndr->depth++;
24367                 if (r->in.data_type) {
24368                         ndr_print_string(ndr, "data_type", r->in.data_type);
24369                 }
24370                 ndr->depth--;
24371                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24372                 ndr->depth++;
24373                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24374                 ndr->depth--;
24375                 ndr->depth--;
24376         }
24377         if (flags & NDR_OUT) {
24378                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
24379                 ndr->depth++;
24380                 ndr_print_WERROR(ndr, "result", r->out.result);
24381                 ndr->depth--;
24382         }
24383         ndr->depth--;
24384 }
24385
24386 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
24387 {
24388         if (flags & NDR_IN) {
24389                 if (r->in.handle == NULL) {
24390                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24391                 }
24392                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24393                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
24394                 if (r->in.architecture) {
24395                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24396                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24397                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24398                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24399                 }
24400                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24402                 if (r->in.buffer) {
24403                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24404                 }
24405                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24406                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
24407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
24408         }
24409         if (flags & NDR_OUT) {
24410                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24411                 if (r->out.info) {
24412                         {
24413                                 struct ndr_push *_ndr_info;
24414                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24415                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24416                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24417                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24418                         }
24419                 }
24420                 if (r->out.needed == NULL) {
24421                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24422                 }
24423                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24424                 if (r->out.server_major_version == NULL) {
24425                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24426                 }
24427                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24428                 if (r->out.server_minor_version == NULL) {
24429                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24430                 }
24431                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24432                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24433         }
24434         return NDR_ERR_SUCCESS;
24435 }
24436
24437 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24438 {
24439         uint32_t _ptr_architecture;
24440         uint32_t _ptr_buffer;
24441         uint32_t _ptr_info;
24442         TALLOC_CTX *_mem_save_handle_0;
24443         TALLOC_CTX *_mem_save_architecture_0;
24444         TALLOC_CTX *_mem_save_buffer_0;
24445         TALLOC_CTX *_mem_save_info_0;
24446         TALLOC_CTX *_mem_save_needed_0;
24447         TALLOC_CTX *_mem_save_server_major_version_0;
24448         TALLOC_CTX *_mem_save_server_minor_version_0;
24449         if (flags & NDR_IN) {
24450                 ZERO_STRUCT(r->out);
24451
24452                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24453                         NDR_PULL_ALLOC(ndr, r->in.handle);
24454                 }
24455                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24456                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24457                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24458                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24459                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24460                 if (_ptr_architecture) {
24461                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24462                 } else {
24463                         r->in.architecture = NULL;
24464                 }
24465                 if (r->in.architecture) {
24466                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24467                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24468                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24469                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24470                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24471                                 return 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));
24472                         }
24473                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24474                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24475                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24476                 }
24477                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24479                 if (_ptr_buffer) {
24480                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24481                 } else {
24482                         r->in.buffer = NULL;
24483                 }
24484                 if (r->in.buffer) {
24485                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24486                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24487                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24488                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24489                 }
24490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24492                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24493                 NDR_PULL_ALLOC(ndr, r->out.needed);
24494                 ZERO_STRUCTP(r->out.needed);
24495                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24496                 ZERO_STRUCTP(r->out.server_major_version);
24497                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24498                 ZERO_STRUCTP(r->out.server_minor_version);
24499         }
24500         if (flags & NDR_OUT) {
24501                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24502                 if (_ptr_info) {
24503                         NDR_PULL_ALLOC(ndr, r->out.info);
24504                 } else {
24505                         r->out.info = NULL;
24506                 }
24507                 if (r->out.info) {
24508                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24509                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24510                         {
24511                                 struct ndr_pull *_ndr_info;
24512                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24513                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24514                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24515                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24516                         }
24517                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24518                 }
24519                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24520                         NDR_PULL_ALLOC(ndr, r->out.needed);
24521                 }
24522                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24523                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24524                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24526                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24527                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24528                 }
24529                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24530                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24531                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24532                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24533                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24534                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24535                 }
24536                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24537                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24541         }
24542         return NDR_ERR_SUCCESS;
24543 }
24544
24545 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24546 {
24547         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24548         ndr->depth++;
24549         if (flags & NDR_SET_VALUES) {
24550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24551         }
24552         if (flags & NDR_IN) {
24553                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24554                 ndr->depth++;
24555                 ndr_print_ptr(ndr, "handle", r->in.handle);
24556                 ndr->depth++;
24557                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24558                 ndr->depth--;
24559                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24560                 ndr->depth++;
24561                 if (r->in.architecture) {
24562                         ndr_print_string(ndr, "architecture", r->in.architecture);
24563                 }
24564                 ndr->depth--;
24565                 ndr_print_uint32(ndr, "level", r->in.level);
24566                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24567                 ndr->depth++;
24568                 if (r->in.buffer) {
24569                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24570                 }
24571                 ndr->depth--;
24572                 ndr_print_uint32(ndr, "offered", r->in.offered);
24573                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24574                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24575                 ndr->depth--;
24576         }
24577         if (flags & NDR_OUT) {
24578                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24579                 ndr->depth++;
24580                 ndr_print_ptr(ndr, "info", r->out.info);
24581                 ndr->depth++;
24582                 if (r->out.info) {
24583                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24584                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24585                 }
24586                 ndr->depth--;
24587                 ndr_print_ptr(ndr, "needed", r->out.needed);
24588                 ndr->depth++;
24589                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24590                 ndr->depth--;
24591                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24592                 ndr->depth++;
24593                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24594                 ndr->depth--;
24595                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24596                 ndr->depth++;
24597                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24598                 ndr->depth--;
24599                 ndr_print_WERROR(ndr, "result", r->out.result);
24600                 ndr->depth--;
24601         }
24602         ndr->depth--;
24603 }
24604
24605 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24606 {
24607         if (flags & NDR_IN) {
24608         }
24609         if (flags & NDR_OUT) {
24610                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24611         }
24612         return NDR_ERR_SUCCESS;
24613 }
24614
24615 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24616 {
24617         if (flags & NDR_IN) {
24618         }
24619         if (flags & NDR_OUT) {
24620                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24621         }
24622         return NDR_ERR_SUCCESS;
24623 }
24624
24625 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24626 {
24627         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24628         ndr->depth++;
24629         if (flags & NDR_SET_VALUES) {
24630                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24631         }
24632         if (flags & NDR_IN) {
24633                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24634                 ndr->depth++;
24635                 ndr->depth--;
24636         }
24637         if (flags & NDR_OUT) {
24638                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24639                 ndr->depth++;
24640                 ndr_print_WERROR(ndr, "result", r->out.result);
24641                 ndr->depth--;
24642         }
24643         ndr->depth--;
24644 }
24645
24646 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24647 {
24648         if (flags & NDR_IN) {
24649         }
24650         if (flags & NDR_OUT) {
24651                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24652         }
24653         return NDR_ERR_SUCCESS;
24654 }
24655
24656 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24657 {
24658         if (flags & NDR_IN) {
24659         }
24660         if (flags & NDR_OUT) {
24661                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24662         }
24663         return NDR_ERR_SUCCESS;
24664 }
24665
24666 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24667 {
24668         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24669         ndr->depth++;
24670         if (flags & NDR_SET_VALUES) {
24671                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24672         }
24673         if (flags & NDR_IN) {
24674                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24675                 ndr->depth++;
24676                 ndr->depth--;
24677         }
24678         if (flags & NDR_OUT) {
24679                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24680                 ndr->depth++;
24681                 ndr_print_WERROR(ndr, "result", r->out.result);
24682                 ndr->depth--;
24683         }
24684         ndr->depth--;
24685 }
24686
24687 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24688 {
24689         if (flags & NDR_IN) {
24690                 if (r->in.handle == NULL) {
24691                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24692                 }
24693                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24694         }
24695         if (flags & NDR_OUT) {
24696                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24697         }
24698         return NDR_ERR_SUCCESS;
24699 }
24700
24701 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24702 {
24703         TALLOC_CTX *_mem_save_handle_0;
24704         if (flags & NDR_IN) {
24705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24706                         NDR_PULL_ALLOC(ndr, r->in.handle);
24707                 }
24708                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24709                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24710                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24712         }
24713         if (flags & NDR_OUT) {
24714                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24715         }
24716         return NDR_ERR_SUCCESS;
24717 }
24718
24719 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24720 {
24721         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24722         ndr->depth++;
24723         if (flags & NDR_SET_VALUES) {
24724                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24725         }
24726         if (flags & NDR_IN) {
24727                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24728                 ndr->depth++;
24729                 ndr_print_ptr(ndr, "handle", r->in.handle);
24730                 ndr->depth++;
24731                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24732                 ndr->depth--;
24733                 ndr->depth--;
24734         }
24735         if (flags & NDR_OUT) {
24736                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24737                 ndr->depth++;
24738                 ndr_print_WERROR(ndr, "result", r->out.result);
24739                 ndr->depth--;
24740         }
24741         ndr->depth--;
24742 }
24743
24744 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24745 {
24746         if (flags & NDR_IN) {
24747         }
24748         if (flags & NDR_OUT) {
24749                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24750         }
24751         return NDR_ERR_SUCCESS;
24752 }
24753
24754 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24755 {
24756         if (flags & NDR_IN) {
24757         }
24758         if (flags & NDR_OUT) {
24759                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24760         }
24761         return NDR_ERR_SUCCESS;
24762 }
24763
24764 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24765 {
24766         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24767         ndr->depth++;
24768         if (flags & NDR_SET_VALUES) {
24769                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24770         }
24771         if (flags & NDR_IN) {
24772                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24773                 ndr->depth++;
24774                 ndr->depth--;
24775         }
24776         if (flags & NDR_OUT) {
24777                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24778                 ndr->depth++;
24779                 ndr_print_WERROR(ndr, "result", r->out.result);
24780                 ndr->depth--;
24781         }
24782         ndr->depth--;
24783 }
24784
24785 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24786 {
24787         if (flags & NDR_IN) {
24788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24791                 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));
24792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24793                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24795                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24796                 if (r->in.buffer) {
24797                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24798                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24799                 }
24800         }
24801         if (flags & NDR_OUT) {
24802                 if (r->out.handle == NULL) {
24803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24804                 }
24805                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24806                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24807         }
24808         return NDR_ERR_SUCCESS;
24809 }
24810
24811 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24812 {
24813         uint32_t _ptr_buffer;
24814         TALLOC_CTX *_mem_save_buffer_0;
24815         TALLOC_CTX *_mem_save_handle_0;
24816         if (flags & NDR_IN) {
24817                 ZERO_STRUCT(r->out);
24818
24819                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24820                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24821                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24822                         return 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));
24823                 }
24824                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24825                 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));
24826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24827                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24828                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24829                 if (r->in.bufsize > 512) {
24830                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24831                 }
24832                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24833                 if (_ptr_buffer) {
24834                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24835                 } else {
24836                         r->in.buffer = NULL;
24837                 }
24838                 if (r->in.buffer) {
24839                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24840                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24841                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24842                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24843                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24844                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24845                 }
24846                 NDR_PULL_ALLOC(ndr, r->out.handle);
24847                 ZERO_STRUCTP(r->out.handle);
24848                 if (r->in.buffer) {
24849                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24850                 }
24851         }
24852         if (flags & NDR_OUT) {
24853                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24854                         NDR_PULL_ALLOC(ndr, r->out.handle);
24855                 }
24856                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24857                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24858                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24859                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24860                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24861         }
24862         return NDR_ERR_SUCCESS;
24863 }
24864
24865 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24866 {
24867         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24868         ndr->depth++;
24869         if (flags & NDR_SET_VALUES) {
24870                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24871         }
24872         if (flags & NDR_IN) {
24873                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24874                 ndr->depth++;
24875                 ndr_print_string(ndr, "server_name", r->in.server_name);
24876                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24877                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24878                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24879                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24880                 ndr->depth++;
24881                 if (r->in.buffer) {
24882                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24883                 }
24884                 ndr->depth--;
24885                 ndr->depth--;
24886         }
24887         if (flags & NDR_OUT) {
24888                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24889                 ndr->depth++;
24890                 ndr_print_ptr(ndr, "handle", r->out.handle);
24891                 ndr->depth++;
24892                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24893                 ndr->depth--;
24894                 ndr_print_WERROR(ndr, "result", r->out.result);
24895                 ndr->depth--;
24896         }
24897         ndr->depth--;
24898 }
24899
24900 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24901 {
24902         if (flags & NDR_IN) {
24903                 if (r->in.handle == NULL) {
24904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24905                 }
24906                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24907                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24910                 if (r->in.buffer) {
24911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24912                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24913                 }
24914         }
24915         if (flags & NDR_OUT) {
24916                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24917         }
24918         return NDR_ERR_SUCCESS;
24919 }
24920
24921 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24922 {
24923         uint32_t _ptr_buffer;
24924         TALLOC_CTX *_mem_save_handle_0;
24925         TALLOC_CTX *_mem_save_buffer_0;
24926         if (flags & NDR_IN) {
24927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24928                         NDR_PULL_ALLOC(ndr, r->in.handle);
24929                 }
24930                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24931                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24932                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24934                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24936                 if (r->in.bufsize > 512) {
24937                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24938                 }
24939                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24940                 if (_ptr_buffer) {
24941                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24942                 } else {
24943                         r->in.buffer = NULL;
24944                 }
24945                 if (r->in.buffer) {
24946                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24947                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24948                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24949                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24950                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24951                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24952                 }
24953                 if (r->in.buffer) {
24954                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24955                 }
24956         }
24957         if (flags & NDR_OUT) {
24958                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24959         }
24960         return NDR_ERR_SUCCESS;
24961 }
24962
24963 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24964 {
24965         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24966         ndr->depth++;
24967         if (flags & NDR_SET_VALUES) {
24968                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24969         }
24970         if (flags & NDR_IN) {
24971                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24972                 ndr->depth++;
24973                 ndr_print_ptr(ndr, "handle", r->in.handle);
24974                 ndr->depth++;
24975                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24976                 ndr->depth--;
24977                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24978                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24979                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24980                 ndr->depth++;
24981                 if (r->in.buffer) {
24982                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24983                 }
24984                 ndr->depth--;
24985                 ndr->depth--;
24986         }
24987         if (flags & NDR_OUT) {
24988                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24989                 ndr->depth++;
24990                 ndr_print_WERROR(ndr, "result", r->out.result);
24991                 ndr->depth--;
24992         }
24993         ndr->depth--;
24994 }
24995
24996 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24997 {
24998         if (flags & NDR_IN) {
24999                 if (r->in.handle == NULL) {
25000                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25001                 }
25002                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25003         }
25004         if (flags & NDR_OUT) {
25005                 if (r->out.handle == NULL) {
25006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25007                 }
25008                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25009                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25010         }
25011         return NDR_ERR_SUCCESS;
25012 }
25013
25014 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
25015 {
25016         TALLOC_CTX *_mem_save_handle_0;
25017         if (flags & NDR_IN) {
25018                 ZERO_STRUCT(r->out);
25019
25020                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25021                         NDR_PULL_ALLOC(ndr, r->in.handle);
25022                 }
25023                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25024                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25025                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25026                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25027                 NDR_PULL_ALLOC(ndr, r->out.handle);
25028                 *r->out.handle = *r->in.handle;
25029         }
25030         if (flags & NDR_OUT) {
25031                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25032                         NDR_PULL_ALLOC(ndr, r->out.handle);
25033                 }
25034                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25035                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25036                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25037                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25038                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25039         }
25040         return NDR_ERR_SUCCESS;
25041 }
25042
25043 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
25044 {
25045         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
25046         ndr->depth++;
25047         if (flags & NDR_SET_VALUES) {
25048                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25049         }
25050         if (flags & NDR_IN) {
25051                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
25052                 ndr->depth++;
25053                 ndr_print_ptr(ndr, "handle", r->in.handle);
25054                 ndr->depth++;
25055                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25056                 ndr->depth--;
25057                 ndr->depth--;
25058         }
25059         if (flags & NDR_OUT) {
25060                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
25061                 ndr->depth++;
25062                 ndr_print_ptr(ndr, "handle", r->out.handle);
25063                 ndr->depth++;
25064                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25065                 ndr->depth--;
25066                 ndr_print_WERROR(ndr, "result", r->out.result);
25067                 ndr->depth--;
25068         }
25069         ndr->depth--;
25070 }
25071
25072 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
25073 {
25074         if (flags & NDR_IN) {
25075         }
25076         if (flags & NDR_OUT) {
25077                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25078         }
25079         return NDR_ERR_SUCCESS;
25080 }
25081
25082 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
25083 {
25084         if (flags & NDR_IN) {
25085         }
25086         if (flags & NDR_OUT) {
25087                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25088         }
25089         return NDR_ERR_SUCCESS;
25090 }
25091
25092 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
25093 {
25094         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
25095         ndr->depth++;
25096         if (flags & NDR_SET_VALUES) {
25097                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25098         }
25099         if (flags & NDR_IN) {
25100                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
25101                 ndr->depth++;
25102                 ndr->depth--;
25103         }
25104         if (flags & NDR_OUT) {
25105                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
25106                 ndr->depth++;
25107                 ndr_print_WERROR(ndr, "result", r->out.result);
25108                 ndr->depth--;
25109         }
25110         ndr->depth--;
25111 }
25112
25113 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25114 {
25115         if (flags & NDR_IN) {
25116         }
25117         if (flags & NDR_OUT) {
25118                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25119         }
25120         return NDR_ERR_SUCCESS;
25121 }
25122
25123 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25124 {
25125         if (flags & NDR_IN) {
25126         }
25127         if (flags & NDR_OUT) {
25128                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25129         }
25130         return NDR_ERR_SUCCESS;
25131 }
25132
25133 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25134 {
25135         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
25136         ndr->depth++;
25137         if (flags & NDR_SET_VALUES) {
25138                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25139         }
25140         if (flags & NDR_IN) {
25141                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
25142                 ndr->depth++;
25143                 ndr->depth--;
25144         }
25145         if (flags & NDR_OUT) {
25146                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
25147                 ndr->depth++;
25148                 ndr_print_WERROR(ndr, "result", r->out.result);
25149                 ndr->depth--;
25150         }
25151         ndr->depth--;
25152 }
25153
25154 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
25155 {
25156         if (flags & NDR_IN) {
25157         }
25158         if (flags & NDR_OUT) {
25159                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25160         }
25161         return NDR_ERR_SUCCESS;
25162 }
25163
25164 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
25165 {
25166         if (flags & NDR_IN) {
25167         }
25168         if (flags & NDR_OUT) {
25169                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25170         }
25171         return NDR_ERR_SUCCESS;
25172 }
25173
25174 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
25175 {
25176         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
25177         ndr->depth++;
25178         if (flags & NDR_SET_VALUES) {
25179                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25180         }
25181         if (flags & NDR_IN) {
25182                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
25183                 ndr->depth++;
25184                 ndr->depth--;
25185         }
25186         if (flags & NDR_OUT) {
25187                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
25188                 ndr->depth++;
25189                 ndr_print_WERROR(ndr, "result", r->out.result);
25190                 ndr->depth--;
25191         }
25192         ndr->depth--;
25193 }
25194
25195 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
25196 {
25197         if (flags & NDR_IN) {
25198         }
25199         if (flags & NDR_OUT) {
25200                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25201         }
25202         return NDR_ERR_SUCCESS;
25203 }
25204
25205 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
25206 {
25207         if (flags & NDR_IN) {
25208         }
25209         if (flags & NDR_OUT) {
25210                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25211         }
25212         return NDR_ERR_SUCCESS;
25213 }
25214
25215 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
25216 {
25217         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
25218         ndr->depth++;
25219         if (flags & NDR_SET_VALUES) {
25220                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25221         }
25222         if (flags & NDR_IN) {
25223                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
25224                 ndr->depth++;
25225                 ndr->depth--;
25226         }
25227         if (flags & NDR_OUT) {
25228                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
25229                 ndr->depth++;
25230                 ndr_print_WERROR(ndr, "result", r->out.result);
25231                 ndr->depth--;
25232         }
25233         ndr->depth--;
25234 }
25235
25236 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25237 {
25238         if (flags & NDR_IN) {
25239                 if (r->in.handle == NULL) {
25240                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25241                 }
25242                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25243                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25244                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
25245                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
25246                 if (r->in.local_machine) {
25247                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25248                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25249                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25250                         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));
25251                 }
25252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25253                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
25254                 if (r->in.notify_options) {
25255                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25256                 }
25257         }
25258         if (flags & NDR_OUT) {
25259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25260         }
25261         return NDR_ERR_SUCCESS;
25262 }
25263
25264 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25265 {
25266         uint32_t _ptr_local_machine;
25267         uint32_t _ptr_notify_options;
25268         TALLOC_CTX *_mem_save_handle_0;
25269         TALLOC_CTX *_mem_save_local_machine_0;
25270         TALLOC_CTX *_mem_save_notify_options_0;
25271         if (flags & NDR_IN) {
25272                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25273                         NDR_PULL_ALLOC(ndr, r->in.handle);
25274                 }
25275                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25276                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25277                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25278                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25279                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25280                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
25281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
25282                 if (_ptr_local_machine) {
25283                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
25284                 } else {
25285                         r->in.local_machine = NULL;
25286                 }
25287                 if (r->in.local_machine) {
25288                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
25289                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
25290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
25291                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
25292                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
25293                                 return 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));
25294                         }
25295                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
25296                         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));
25297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
25298                 }
25299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25300                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
25301                 if (_ptr_notify_options) {
25302                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
25303                 } else {
25304                         r->in.notify_options = NULL;
25305                 }
25306                 if (r->in.notify_options) {
25307                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25308                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
25309                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
25311                 }
25312         }
25313         if (flags & NDR_OUT) {
25314                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25315         }
25316         return NDR_ERR_SUCCESS;
25317 }
25318
25319 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25320 {
25321         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25322         ndr->depth++;
25323         if (flags & NDR_SET_VALUES) {
25324                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25325         }
25326         if (flags & NDR_IN) {
25327                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25328                 ndr->depth++;
25329                 ndr_print_ptr(ndr, "handle", r->in.handle);
25330                 ndr->depth++;
25331                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25332                 ndr->depth--;
25333                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25334                 ndr_print_uint32(ndr, "options", r->in.options);
25335                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
25336                 ndr->depth++;
25337                 if (r->in.local_machine) {
25338                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
25339                 }
25340                 ndr->depth--;
25341                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25342                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
25343                 ndr->depth++;
25344                 if (r->in.notify_options) {
25345                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
25346                 }
25347                 ndr->depth--;
25348                 ndr->depth--;
25349         }
25350         if (flags & NDR_OUT) {
25351                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25352                 ndr->depth++;
25353                 ndr_print_WERROR(ndr, "result", r->out.result);
25354                 ndr->depth--;
25355         }
25356         ndr->depth--;
25357 }
25358
25359 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25360 {
25361         if (flags & NDR_IN) {
25362                 if (r->in.handle == NULL) {
25363                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25364                 }
25365                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
25367                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25368                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
25369                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25370                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25371         }
25372         if (flags & NDR_OUT) {
25373                 if (r->out.reply_result == NULL) {
25374                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25375                 }
25376                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
25377                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25378         }
25379         return NDR_ERR_SUCCESS;
25380 }
25381
25382 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
25383 {
25384         TALLOC_CTX *_mem_save_handle_0;
25385         TALLOC_CTX *_mem_save_reply_result_0;
25386         if (flags & NDR_IN) {
25387                 ZERO_STRUCT(r->out);
25388
25389                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25390                         NDR_PULL_ALLOC(ndr, r->in.handle);
25391                 }
25392                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25393                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25394                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25395                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
25397                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
25399                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25400                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25401                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
25402                 ZERO_STRUCTP(r->out.reply_result);
25403         }
25404         if (flags & NDR_OUT) {
25405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25406                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
25407                 }
25408                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
25409                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
25410                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
25411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
25412                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25413         }
25414         return NDR_ERR_SUCCESS;
25415 }
25416
25417 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25418 {
25419         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
25420         ndr->depth++;
25421         if (flags & NDR_SET_VALUES) {
25422                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25423         }
25424         if (flags & NDR_IN) {
25425                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25426                 ndr->depth++;
25427                 ndr_print_ptr(ndr, "handle", r->in.handle);
25428                 ndr->depth++;
25429                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25430                 ndr->depth--;
25431                 ndr_print_uint32(ndr, "color", r->in.color);
25432                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25433                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25434                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25435                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25436                 ndr->depth--;
25437         }
25438         if (flags & NDR_OUT) {
25439                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25440                 ndr->depth++;
25441                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25442                 ndr->depth++;
25443                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25444                 ndr->depth--;
25445                 ndr_print_WERROR(ndr, "result", r->out.result);
25446                 ndr->depth--;
25447         }
25448         ndr->depth--;
25449 }
25450
25451 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25452 {
25453         if (flags & NDR_IN) {
25454                 if (r->in.handle == NULL) {
25455                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25456                 }
25457                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25458                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25459                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25460                 if (r->in.options) {
25461                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25462                 }
25463         }
25464         if (flags & NDR_OUT) {
25465                 if (r->out.info == NULL) {
25466                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25467                 }
25468                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25469                 if (*r->out.info) {
25470                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25471                 }
25472                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25473         }
25474         return NDR_ERR_SUCCESS;
25475 }
25476
25477 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25478 {
25479         uint32_t _ptr_options;
25480         uint32_t _ptr_info;
25481         TALLOC_CTX *_mem_save_handle_0;
25482         TALLOC_CTX *_mem_save_options_0;
25483         TALLOC_CTX *_mem_save_info_0;
25484         TALLOC_CTX *_mem_save_info_1;
25485         if (flags & NDR_IN) {
25486                 ZERO_STRUCT(r->out);
25487
25488                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25489                         NDR_PULL_ALLOC(ndr, r->in.handle);
25490                 }
25491                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25492                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25493                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25494                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25497                 if (_ptr_options) {
25498                         NDR_PULL_ALLOC(ndr, r->in.options);
25499                 } else {
25500                         r->in.options = NULL;
25501                 }
25502                 if (r->in.options) {
25503                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25504                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25505                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25506                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25507                 }
25508                 NDR_PULL_ALLOC(ndr, r->out.info);
25509                 ZERO_STRUCTP(r->out.info);
25510         }
25511         if (flags & NDR_OUT) {
25512                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25513                         NDR_PULL_ALLOC(ndr, r->out.info);
25514                 }
25515                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25516                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25517                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25518                 if (_ptr_info) {
25519                         NDR_PULL_ALLOC(ndr, *r->out.info);
25520                 } else {
25521                         *r->out.info = NULL;
25522                 }
25523                 if (*r->out.info) {
25524                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25525                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25526                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25527                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25528                 }
25529                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25530                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25531         }
25532         return NDR_ERR_SUCCESS;
25533 }
25534
25535 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25536 {
25537         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25538         ndr->depth++;
25539         if (flags & NDR_SET_VALUES) {
25540                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25541         }
25542         if (flags & NDR_IN) {
25543                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25544                 ndr->depth++;
25545                 ndr_print_ptr(ndr, "handle", r->in.handle);
25546                 ndr->depth++;
25547                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25548                 ndr->depth--;
25549                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25550                 ndr_print_ptr(ndr, "options", r->in.options);
25551                 ndr->depth++;
25552                 if (r->in.options) {
25553                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25554                 }
25555                 ndr->depth--;
25556                 ndr->depth--;
25557         }
25558         if (flags & NDR_OUT) {
25559                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25560                 ndr->depth++;
25561                 ndr_print_ptr(ndr, "info", r->out.info);
25562                 ndr->depth++;
25563                 ndr_print_ptr(ndr, "info", *r->out.info);
25564                 ndr->depth++;
25565                 if (*r->out.info) {
25566                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25567                 }
25568                 ndr->depth--;
25569                 ndr->depth--;
25570                 ndr_print_WERROR(ndr, "result", r->out.result);
25571                 ndr->depth--;
25572         }
25573         ndr->depth--;
25574 }
25575
25576 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25577 {
25578         if (flags & NDR_IN) {
25579         }
25580         if (flags & NDR_OUT) {
25581                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25582         }
25583         return NDR_ERR_SUCCESS;
25584 }
25585
25586 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25587 {
25588         if (flags & NDR_IN) {
25589         }
25590         if (flags & NDR_OUT) {
25591                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25592         }
25593         return NDR_ERR_SUCCESS;
25594 }
25595
25596 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25597 {
25598         ndr_print_struct(ndr, name, "spoolss_44");
25599         ndr->depth++;
25600         if (flags & NDR_SET_VALUES) {
25601                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25602         }
25603         if (flags & NDR_IN) {
25604                 ndr_print_struct(ndr, "in", "spoolss_44");
25605                 ndr->depth++;
25606                 ndr->depth--;
25607         }
25608         if (flags & NDR_OUT) {
25609                 ndr_print_struct(ndr, "out", "spoolss_44");
25610                 ndr->depth++;
25611                 ndr_print_WERROR(ndr, "result", r->out.result);
25612                 ndr->depth--;
25613         }
25614         ndr->depth--;
25615 }
25616
25617 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25618 {
25619         if (flags & NDR_IN) {
25620                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25621                 if (r->in.printername) {
25622                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25623                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25624                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25625                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25626                 }
25627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25628                 if (r->in.datatype) {
25629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25631                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25632                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25633                 }
25634                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25635                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25637                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25638                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25639         }
25640         if (flags & NDR_OUT) {
25641                 if (r->out.handle == NULL) {
25642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25643                 }
25644                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25645                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25646         }
25647         return NDR_ERR_SUCCESS;
25648 }
25649
25650 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25651 {
25652         uint32_t _ptr_printername;
25653         uint32_t _ptr_datatype;
25654         TALLOC_CTX *_mem_save_printername_0;
25655         TALLOC_CTX *_mem_save_datatype_0;
25656         TALLOC_CTX *_mem_save_handle_0;
25657         if (flags & NDR_IN) {
25658                 ZERO_STRUCT(r->out);
25659
25660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25661                 if (_ptr_printername) {
25662                         NDR_PULL_ALLOC(ndr, r->in.printername);
25663                 } else {
25664                         r->in.printername = NULL;
25665                 }
25666                 if (r->in.printername) {
25667                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25668                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25669                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25670                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25671                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25672                                 return 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));
25673                         }
25674                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25675                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25677                 }
25678                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25679                 if (_ptr_datatype) {
25680                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25681                 } else {
25682                         r->in.datatype = NULL;
25683                 }
25684                 if (r->in.datatype) {
25685                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25686                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25687                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25688                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25689                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25690                                 return 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));
25691                         }
25692                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25693                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25694                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25695                 }
25696                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25697                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25699                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25700                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25701                 NDR_PULL_ALLOC(ndr, r->out.handle);
25702                 ZERO_STRUCTP(r->out.handle);
25703         }
25704         if (flags & NDR_OUT) {
25705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25706                         NDR_PULL_ALLOC(ndr, r->out.handle);
25707                 }
25708                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25709                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25710                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25712                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25713         }
25714         return NDR_ERR_SUCCESS;
25715 }
25716
25717 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25718 {
25719         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25720         ndr->depth++;
25721         if (flags & NDR_SET_VALUES) {
25722                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25723         }
25724         if (flags & NDR_IN) {
25725                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25726                 ndr->depth++;
25727                 ndr_print_ptr(ndr, "printername", r->in.printername);
25728                 ndr->depth++;
25729                 if (r->in.printername) {
25730                         ndr_print_string(ndr, "printername", r->in.printername);
25731                 }
25732                 ndr->depth--;
25733                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25734                 ndr->depth++;
25735                 if (r->in.datatype) {
25736                         ndr_print_string(ndr, "datatype", r->in.datatype);
25737                 }
25738                 ndr->depth--;
25739                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25740                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25741                 ndr_print_uint32(ndr, "level", r->in.level);
25742                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25743                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25744                 ndr->depth--;
25745         }
25746         if (flags & NDR_OUT) {
25747                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25748                 ndr->depth++;
25749                 ndr_print_ptr(ndr, "handle", r->out.handle);
25750                 ndr->depth++;
25751                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25752                 ndr->depth--;
25753                 ndr_print_WERROR(ndr, "result", r->out.result);
25754                 ndr->depth--;
25755         }
25756         ndr->depth--;
25757 }
25758
25759 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25760 {
25761         if (flags & NDR_IN) {
25762                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25763                 if (r->in.server) {
25764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25765                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25767                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25768                 }
25769                 if (r->in.info_ctr == NULL) {
25770                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25771                 }
25772                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25773                 if (r->in.devmode_ctr == NULL) {
25774                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25775                 }
25776                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25777                 if (r->in.secdesc_ctr == NULL) {
25778                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25779                 }
25780                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25781                 if (r->in.userlevel_ctr == NULL) {
25782                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25783                 }
25784                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25785         }
25786         if (flags & NDR_OUT) {
25787                 if (r->out.handle == NULL) {
25788                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25789                 }
25790                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25791                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25792         }
25793         return NDR_ERR_SUCCESS;
25794 }
25795
25796 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25797 {
25798         uint32_t _ptr_server;
25799         TALLOC_CTX *_mem_save_server_0;
25800         TALLOC_CTX *_mem_save_info_ctr_0;
25801         TALLOC_CTX *_mem_save_devmode_ctr_0;
25802         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25803         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25804         TALLOC_CTX *_mem_save_handle_0;
25805         if (flags & NDR_IN) {
25806                 ZERO_STRUCT(r->out);
25807
25808                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25809                 if (_ptr_server) {
25810                         NDR_PULL_ALLOC(ndr, r->in.server);
25811                 } else {
25812                         r->in.server = NULL;
25813                 }
25814                 if (r->in.server) {
25815                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25816                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25817                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25818                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25819                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25820                                 return 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));
25821                         }
25822                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25823                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25824                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25825                 }
25826                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25827                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25828                 }
25829                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25830                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25831                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25832                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25833                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25834                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25835                 }
25836                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25837                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25838                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25839                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25840                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25841                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25842                 }
25843                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25844                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25845                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25846                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25847                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25848                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25849                 }
25850                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25851                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25852                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25853                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25854                 NDR_PULL_ALLOC(ndr, r->out.handle);
25855                 ZERO_STRUCTP(r->out.handle);
25856         }
25857         if (flags & NDR_OUT) {
25858                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25859                         NDR_PULL_ALLOC(ndr, r->out.handle);
25860                 }
25861                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25862                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25863                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25864                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25865                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25866         }
25867         return NDR_ERR_SUCCESS;
25868 }
25869
25870 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25871 {
25872         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25873         ndr->depth++;
25874         if (flags & NDR_SET_VALUES) {
25875                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25876         }
25877         if (flags & NDR_IN) {
25878                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25879                 ndr->depth++;
25880                 ndr_print_ptr(ndr, "server", r->in.server);
25881                 ndr->depth++;
25882                 if (r->in.server) {
25883                         ndr_print_string(ndr, "server", r->in.server);
25884                 }
25885                 ndr->depth--;
25886                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25887                 ndr->depth++;
25888                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25889                 ndr->depth--;
25890                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25891                 ndr->depth++;
25892                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25893                 ndr->depth--;
25894                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25895                 ndr->depth++;
25896                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25897                 ndr->depth--;
25898                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25899                 ndr->depth++;
25900                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25901                 ndr->depth--;
25902                 ndr->depth--;
25903         }
25904         if (flags & NDR_OUT) {
25905                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25906                 ndr->depth++;
25907                 ndr_print_ptr(ndr, "handle", r->out.handle);
25908                 ndr->depth++;
25909                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25910                 ndr->depth--;
25911                 ndr_print_WERROR(ndr, "result", r->out.result);
25912                 ndr->depth--;
25913         }
25914         ndr->depth--;
25915 }
25916
25917 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25918 {
25919         if (flags & NDR_IN) {
25920         }
25921         if (flags & NDR_OUT) {
25922                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25923         }
25924         return NDR_ERR_SUCCESS;
25925 }
25926
25927 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25928 {
25929         if (flags & NDR_IN) {
25930         }
25931         if (flags & NDR_OUT) {
25932                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25933         }
25934         return NDR_ERR_SUCCESS;
25935 }
25936
25937 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25938 {
25939         ndr_print_struct(ndr, name, "spoolss_47");
25940         ndr->depth++;
25941         if (flags & NDR_SET_VALUES) {
25942                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25943         }
25944         if (flags & NDR_IN) {
25945                 ndr_print_struct(ndr, "in", "spoolss_47");
25946                 ndr->depth++;
25947                 ndr->depth--;
25948         }
25949         if (flags & NDR_OUT) {
25950                 ndr_print_struct(ndr, "out", "spoolss_47");
25951                 ndr->depth++;
25952                 ndr_print_WERROR(ndr, "result", r->out.result);
25953                 ndr->depth--;
25954         }
25955         ndr->depth--;
25956 }
25957
25958 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25959 {
25960         if (flags & NDR_IN) {
25961                 if (r->in.handle == NULL) {
25962                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25963                 }
25964                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25967                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25968         }
25969         if (flags & NDR_OUT) {
25970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25971                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25972                 if (r->out.value_needed == NULL) {
25973                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25974                 }
25975                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25976                 if (r->out.type == NULL) {
25977                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25978                 }
25979                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
25980                 {
25981                         uint32_t _flags_save_uint8 = ndr->flags;
25982                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25983                         if (r->out.data == NULL) {
25984                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25985                         }
25986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25987                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
25988                         ndr->flags = _flags_save_uint8;
25989                 }
25990                 if (r->out.data_needed == NULL) {
25991                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25992                 }
25993                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25994                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25995         }
25996         return NDR_ERR_SUCCESS;
25997 }
25998
25999 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
26000 {
26001         TALLOC_CTX *_mem_save_handle_0;
26002         TALLOC_CTX *_mem_save_value_needed_0;
26003         TALLOC_CTX *_mem_save_type_0;
26004         TALLOC_CTX *_mem_save_data_needed_0;
26005         if (flags & NDR_IN) {
26006                 ZERO_STRUCT(r->out);
26007
26008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26009                         NDR_PULL_ALLOC(ndr, r->in.handle);
26010                 }
26011                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26012                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26013                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26015                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
26016                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
26017                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
26018                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
26019                 ZERO_STRUCTP(r->out.value_needed);
26020                 NDR_PULL_ALLOC(ndr, r->out.type);
26021                 ZERO_STRUCTP(r->out.type);
26022                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
26023                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
26024                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
26025                 ZERO_STRUCTP(r->out.data_needed);
26026         }
26027         if (flags & NDR_OUT) {
26028                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
26029                 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));
26030                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26031                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
26032                 }
26033                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26034                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
26035                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
26036                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
26037                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26038                         NDR_PULL_ALLOC(ndr, r->out.type);
26039                 }
26040                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26041                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26042                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26043                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26044                 {
26045                         uint32_t _flags_save_uint8 = ndr->flags;
26046                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
26047                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
26048                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26049                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
26050                         }
26051                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
26052                         ndr->flags = _flags_save_uint8;
26053                 }
26054                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26055                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
26056                 }
26057                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26058                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
26059                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
26060                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
26061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26062                 if (r->out.value_name) {
26063                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
26064                 }
26065                 if (r->out.data) {
26066                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
26067                 }
26068         }
26069         return NDR_ERR_SUCCESS;
26070 }
26071
26072 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
26073 {
26074         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
26075         ndr->depth++;
26076         if (flags & NDR_SET_VALUES) {
26077                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26078         }
26079         if (flags & NDR_IN) {
26080                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
26081                 ndr->depth++;
26082                 ndr_print_ptr(ndr, "handle", r->in.handle);
26083                 ndr->depth++;
26084                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26085                 ndr->depth--;
26086                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
26087                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
26088                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
26089                 ndr->depth--;
26090         }
26091         if (flags & NDR_OUT) {
26092                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
26093                 ndr->depth++;
26094                 ndr_print_string(ndr, "value_name", r->out.value_name);
26095                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
26096                 ndr->depth++;
26097                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
26098                 ndr->depth--;
26099                 ndr_print_ptr(ndr, "type", r->out.type);
26100                 ndr->depth++;
26101                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26102                 ndr->depth--;
26103                 ndr_print_ptr(ndr, "data", r->out.data);
26104                 ndr->depth++;
26105                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
26106                 ndr->depth--;
26107                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
26108                 ndr->depth++;
26109                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
26110                 ndr->depth--;
26111                 ndr_print_WERROR(ndr, "result", r->out.result);
26112                 ndr->depth--;
26113         }
26114         ndr->depth--;
26115 }
26116
26117 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
26118 {
26119         if (flags & NDR_IN) {
26120                 if (r->in.handle == NULL) {
26121                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26122                 }
26123                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26125                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26126                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26127                 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));
26128         }
26129         if (flags & NDR_OUT) {
26130                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26131         }
26132         return NDR_ERR_SUCCESS;
26133 }
26134
26135 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
26136 {
26137         TALLOC_CTX *_mem_save_handle_0;
26138         if (flags & NDR_IN) {
26139                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26140                         NDR_PULL_ALLOC(ndr, r->in.handle);
26141                 }
26142                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26143                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26144                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26146                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26147                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26148                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26149                         return 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));
26150                 }
26151                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26152                 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));
26153         }
26154         if (flags & NDR_OUT) {
26155                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26156         }
26157         return NDR_ERR_SUCCESS;
26158 }
26159
26160 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
26161 {
26162         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
26163         ndr->depth++;
26164         if (flags & NDR_SET_VALUES) {
26165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26166         }
26167         if (flags & NDR_IN) {
26168                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
26169                 ndr->depth++;
26170                 ndr_print_ptr(ndr, "handle", r->in.handle);
26171                 ndr->depth++;
26172                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26173                 ndr->depth--;
26174                 ndr_print_string(ndr, "value_name", r->in.value_name);
26175                 ndr->depth--;
26176         }
26177         if (flags & NDR_OUT) {
26178                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
26179                 ndr->depth++;
26180                 ndr_print_WERROR(ndr, "result", r->out.result);
26181                 ndr->depth--;
26182         }
26183         ndr->depth--;
26184 }
26185
26186 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
26187 {
26188         if (flags & NDR_IN) {
26189         }
26190         if (flags & NDR_OUT) {
26191                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26192         }
26193         return NDR_ERR_SUCCESS;
26194 }
26195
26196 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
26197 {
26198         if (flags & NDR_IN) {
26199         }
26200         if (flags & NDR_OUT) {
26201                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26202         }
26203         return NDR_ERR_SUCCESS;
26204 }
26205
26206 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
26207 {
26208         ndr_print_struct(ndr, name, "spoolss_4a");
26209         ndr->depth++;
26210         if (flags & NDR_SET_VALUES) {
26211                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26212         }
26213         if (flags & NDR_IN) {
26214                 ndr_print_struct(ndr, "in", "spoolss_4a");
26215                 ndr->depth++;
26216                 ndr->depth--;
26217         }
26218         if (flags & NDR_OUT) {
26219                 ndr_print_struct(ndr, "out", "spoolss_4a");
26220                 ndr->depth++;
26221                 ndr_print_WERROR(ndr, "result", r->out.result);
26222                 ndr->depth--;
26223         }
26224         ndr->depth--;
26225 }
26226
26227 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
26228 {
26229         if (flags & NDR_IN) {
26230         }
26231         if (flags & NDR_OUT) {
26232                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26233         }
26234         return NDR_ERR_SUCCESS;
26235 }
26236
26237 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
26238 {
26239         if (flags & NDR_IN) {
26240         }
26241         if (flags & NDR_OUT) {
26242                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26243         }
26244         return NDR_ERR_SUCCESS;
26245 }
26246
26247 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
26248 {
26249         ndr_print_struct(ndr, name, "spoolss_4b");
26250         ndr->depth++;
26251         if (flags & NDR_SET_VALUES) {
26252                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26253         }
26254         if (flags & NDR_IN) {
26255                 ndr_print_struct(ndr, "in", "spoolss_4b");
26256                 ndr->depth++;
26257                 ndr->depth--;
26258         }
26259         if (flags & NDR_OUT) {
26260                 ndr_print_struct(ndr, "out", "spoolss_4b");
26261                 ndr->depth++;
26262                 ndr_print_WERROR(ndr, "result", r->out.result);
26263                 ndr->depth--;
26264         }
26265         ndr->depth--;
26266 }
26267
26268 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
26269 {
26270         if (flags & NDR_IN) {
26271         }
26272         if (flags & NDR_OUT) {
26273                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26274         }
26275         return NDR_ERR_SUCCESS;
26276 }
26277
26278 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
26279 {
26280         if (flags & NDR_IN) {
26281         }
26282         if (flags & NDR_OUT) {
26283                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26284         }
26285         return NDR_ERR_SUCCESS;
26286 }
26287
26288 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
26289 {
26290         ndr_print_struct(ndr, name, "spoolss_4c");
26291         ndr->depth++;
26292         if (flags & NDR_SET_VALUES) {
26293                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26294         }
26295         if (flags & NDR_IN) {
26296                 ndr_print_struct(ndr, "in", "spoolss_4c");
26297                 ndr->depth++;
26298                 ndr->depth--;
26299         }
26300         if (flags & NDR_OUT) {
26301                 ndr_print_struct(ndr, "out", "spoolss_4c");
26302                 ndr->depth++;
26303                 ndr_print_WERROR(ndr, "result", r->out.result);
26304                 ndr->depth--;
26305         }
26306         ndr->depth--;
26307 }
26308
26309 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
26310 {
26311         if (flags & NDR_IN) {
26312                 if (r->in.handle == NULL) {
26313                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26314                 }
26315                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26319                 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));
26320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26323                 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));
26324                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26325                 if (r->in.buffer == NULL) {
26326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26327                 }
26328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26329                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
26330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26331         }
26332         if (flags & NDR_OUT) {
26333                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26334         }
26335         return NDR_ERR_SUCCESS;
26336 }
26337
26338 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
26339 {
26340         TALLOC_CTX *_mem_save_handle_0;
26341         if (flags & NDR_IN) {
26342                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26343                         NDR_PULL_ALLOC(ndr, r->in.handle);
26344                 }
26345                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26346                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26347                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26348                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26349                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26350                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26351                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26352                         return 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));
26353                 }
26354                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26355                 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));
26356                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26357                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26358                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26359                         return 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));
26360                 }
26361                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26362                 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));
26363                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26364                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26366                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26367                 }
26368                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26369                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26370                 if (r->in.buffer) {
26371                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
26372                 }
26373         }
26374         if (flags & NDR_OUT) {
26375                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26376         }
26377         return NDR_ERR_SUCCESS;
26378 }
26379
26380 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
26381 {
26382         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
26383         ndr->depth++;
26384         if (flags & NDR_SET_VALUES) {
26385                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26386         }
26387         if (flags & NDR_IN) {
26388                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
26389                 ndr->depth++;
26390                 ndr_print_ptr(ndr, "handle", r->in.handle);
26391                 ndr->depth++;
26392                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26393                 ndr->depth--;
26394                 ndr_print_string(ndr, "key_name", r->in.key_name);
26395                 ndr_print_string(ndr, "value_name", r->in.value_name);
26396                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26397                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26398                 ndr->depth++;
26399                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
26400                 ndr->depth--;
26401                 ndr_print_uint32(ndr, "offered", r->in.offered);
26402                 ndr->depth--;
26403         }
26404         if (flags & NDR_OUT) {
26405                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
26406                 ndr->depth++;
26407                 ndr_print_WERROR(ndr, "result", r->out.result);
26408                 ndr->depth--;
26409         }
26410         ndr->depth--;
26411 }
26412
26413 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
26414 {
26415         if (flags & NDR_IN) {
26416                 if (r->in.handle == NULL) {
26417                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26418                 }
26419                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26420                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26421                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26422                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26423                 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));
26424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26425                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26427                 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));
26428                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26429         }
26430         if (flags & NDR_OUT) {
26431                 if (r->out.type == NULL) {
26432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26433                 }
26434                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26435                 if (r->out.buffer == NULL) {
26436                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26437                 }
26438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26439                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26440                 if (r->out.needed == NULL) {
26441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26442                 }
26443                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26444                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26445         }
26446         return NDR_ERR_SUCCESS;
26447 }
26448
26449 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26450 {
26451         TALLOC_CTX *_mem_save_handle_0;
26452         TALLOC_CTX *_mem_save_type_0;
26453         TALLOC_CTX *_mem_save_needed_0;
26454         if (flags & NDR_IN) {
26455                 ZERO_STRUCT(r->out);
26456
26457                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26458                         NDR_PULL_ALLOC(ndr, r->in.handle);
26459                 }
26460                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26461                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26462                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26463                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26464                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26465                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26466                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26467                         return 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));
26468                 }
26469                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26470                 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));
26471                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26472                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26473                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26474                         return 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));
26475                 }
26476                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26477                 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));
26478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26479                 NDR_PULL_ALLOC(ndr, r->out.type);
26480                 ZERO_STRUCTP(r->out.type);
26481                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26482                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26483                 NDR_PULL_ALLOC(ndr, r->out.needed);
26484                 ZERO_STRUCTP(r->out.needed);
26485         }
26486         if (flags & NDR_OUT) {
26487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26488                         NDR_PULL_ALLOC(ndr, r->out.type);
26489                 }
26490                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26491                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26492                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26494                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26495                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26496                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26497                 }
26498                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26499                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26500                         NDR_PULL_ALLOC(ndr, r->out.needed);
26501                 }
26502                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26503                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26504                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26505                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26506                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26507                 if (r->out.buffer) {
26508                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26509                 }
26510         }
26511         return NDR_ERR_SUCCESS;
26512 }
26513
26514 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26515 {
26516         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26517         ndr->depth++;
26518         if (flags & NDR_SET_VALUES) {
26519                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26520         }
26521         if (flags & NDR_IN) {
26522                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26523                 ndr->depth++;
26524                 ndr_print_ptr(ndr, "handle", r->in.handle);
26525                 ndr->depth++;
26526                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26527                 ndr->depth--;
26528                 ndr_print_string(ndr, "key_name", r->in.key_name);
26529                 ndr_print_string(ndr, "value_name", r->in.value_name);
26530                 ndr_print_uint32(ndr, "offered", r->in.offered);
26531                 ndr->depth--;
26532         }
26533         if (flags & NDR_OUT) {
26534                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26535                 ndr->depth++;
26536                 ndr_print_ptr(ndr, "type", r->out.type);
26537                 ndr->depth++;
26538                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26539                 ndr->depth--;
26540                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26541                 ndr->depth++;
26542                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26543                 ndr->depth--;
26544                 ndr_print_ptr(ndr, "needed", r->out.needed);
26545                 ndr->depth++;
26546                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26547                 ndr->depth--;
26548                 ndr_print_WERROR(ndr, "result", r->out.result);
26549                 ndr->depth--;
26550         }
26551         ndr->depth--;
26552 }
26553
26554 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
26555 {
26556         if (flags & NDR_IN) {
26557                 if (r->in.handle == NULL) {
26558                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26559                 }
26560                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26561                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26562                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26564                 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));
26565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26566         }
26567         if (flags & NDR_OUT) {
26568                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26569                 if (r->out.needed == NULL) {
26570                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26571                 }
26572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26573                 if (r->out.count == NULL) {
26574                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26575                 }
26576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26577                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26578         }
26579         return NDR_ERR_SUCCESS;
26580 }
26581
26582 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
26583 {
26584         TALLOC_CTX *_mem_save_handle_0;
26585         TALLOC_CTX *_mem_save_needed_0;
26586         TALLOC_CTX *_mem_save_count_0;
26587         if (flags & NDR_IN) {
26588                 ZERO_STRUCT(r->out);
26589
26590                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26591                         NDR_PULL_ALLOC(ndr, r->in.handle);
26592                 }
26593                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26594                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26595                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26596                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26597                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26598                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26599                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26600                         return 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));
26601                 }
26602                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26603                 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));
26604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26605                 NDR_PULL_ALLOC(ndr, r->out.needed);
26606                 ZERO_STRUCTP(r->out.needed);
26607                 NDR_PULL_ALLOC(ndr, r->out.count);
26608                 ZERO_STRUCTP(r->out.count);
26609         }
26610         if (flags & NDR_OUT) {
26611                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
26612                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26613                         NDR_PULL_ALLOC(ndr, r->out.needed);
26614                 }
26615                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26616                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26618                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26619                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26620                         NDR_PULL_ALLOC(ndr, r->out.count);
26621                 }
26622                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26623                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26624                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26625                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26626                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26627         }
26628         return NDR_ERR_SUCCESS;
26629 }
26630
26631 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
26632 {
26633         uint32_t cntr_info_0;
26634         if (flags & NDR_IN) {
26635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26636         }
26637         if (flags & NDR_OUT) {
26638                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26639                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26640                 }
26641                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26642                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26643                 }
26644         }
26645         return NDR_ERR_SUCCESS;
26646 }
26647
26648 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
26649 {
26650         uint32_t cntr_info_0;
26651         TALLOC_CTX *_mem_save_info_0;
26652         if (flags & NDR_IN) {
26653                 ZERO_STRUCT(r->out);
26654
26655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26656         }
26657         if (flags & NDR_OUT) {
26658                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26659                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26660                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26661                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26662                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26663                 }
26664                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26665                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26666                 }
26667                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26668         }
26669         return NDR_ERR_SUCCESS;
26670 }
26671
26672 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26673 {
26674         uint32_t cntr_info_2;
26675         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26676         ndr->depth++;
26677         if (flags & NDR_SET_VALUES) {
26678                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26679         }
26680         if (flags & NDR_IN) {
26681                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26682                 ndr->depth++;
26683                 ndr_print_ptr(ndr, "handle", r->in.handle);
26684                 ndr->depth++;
26685                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26686                 ndr->depth--;
26687                 ndr_print_string(ndr, "key_name", r->in.key_name);
26688                 ndr_print_uint32(ndr, "offered", r->in.offered);
26689                 ndr->depth--;
26690         }
26691         if (flags & NDR_OUT) {
26692                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26693                 ndr->depth++;
26694                 ndr_print_ptr(ndr, "count", r->out.count);
26695                 ndr->depth++;
26696                 ndr_print_uint32(ndr, "count", *r->out.count);
26697                 ndr->depth--;
26698                 ndr_print_ptr(ndr, "info", r->out.info);
26699                 ndr->depth++;
26700                 ndr_print_ptr(ndr, "info", *r->out.info);
26701                 ndr->depth++;
26702                 if (*r->out.info) {
26703                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26704                         ndr->depth++;
26705                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26706                                 char *idx_2=NULL;
26707                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26708                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
26709                                         free(idx_2);
26710                                 }
26711                         }
26712                         ndr->depth--;
26713                 }
26714                 ndr->depth--;
26715                 ndr->depth--;
26716                 ndr_print_ptr(ndr, "needed", r->out.needed);
26717                 ndr->depth++;
26718                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26719                 ndr->depth--;
26720                 ndr_print_WERROR(ndr, "result", r->out.result);
26721                 ndr->depth--;
26722         }
26723         ndr->depth--;
26724 }
26725
26726 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26727 {
26728         if (flags & NDR_IN) {
26729                 if (r->in.handle == NULL) {
26730                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26731                 }
26732                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26733                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26735                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26736                 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));
26737                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26738         }
26739         if (flags & NDR_OUT) {
26740                 if (r->out._ndr_size == NULL) {
26741                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26742                 }
26743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._ndr_size));
26744                 if (r->out.key_buffer == NULL) {
26745                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26746                 }
26747                 {
26748                         struct ndr_push *_ndr_key_buffer;
26749                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
26750                         NDR_CHECK(ndr_push_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
26751                         NDR_CHECK(ndr_push_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
26752                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
26753                 }
26754                 if (r->out.needed == NULL) {
26755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26756                 }
26757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26758                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26759         }
26760         return NDR_ERR_SUCCESS;
26761 }
26762
26763 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26764 {
26765         TALLOC_CTX *_mem_save_handle_0;
26766         TALLOC_CTX *_mem_save__ndr_size_0;
26767         TALLOC_CTX *_mem_save_key_buffer_0;
26768         TALLOC_CTX *_mem_save_needed_0;
26769         if (flags & NDR_IN) {
26770                 ZERO_STRUCT(r->out);
26771
26772                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26773                         NDR_PULL_ALLOC(ndr, r->in.handle);
26774                 }
26775                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26776                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26777                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26778                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26779                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26780                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26781                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26782                         return 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));
26783                 }
26784                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26785                 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));
26786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26787                 NDR_PULL_ALLOC(ndr, r->out._ndr_size);
26788                 ZERO_STRUCTP(r->out._ndr_size);
26789                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26790                 ZERO_STRUCTP(r->out.key_buffer);
26791                 NDR_PULL_ALLOC(ndr, r->out.needed);
26792                 ZERO_STRUCTP(r->out.needed);
26793         }
26794         if (flags & NDR_OUT) {
26795                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26796                         NDR_PULL_ALLOC(ndr, r->out._ndr_size);
26797                 }
26798                 _mem_save__ndr_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
26799                 NDR_PULL_SET_MEM_CTX(ndr, r->out._ndr_size, LIBNDR_FLAG_REF_ALLOC);
26800                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._ndr_size));
26801                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__ndr_size_0, LIBNDR_FLAG_REF_ALLOC);
26802                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26803                         NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26804                 }
26805                 _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26806                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
26807                 {
26808                         struct ndr_pull *_ndr_key_buffer;
26809                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, *r->out._ndr_size * 2));
26810                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_key_buffer, r->out.key_buffer, *r->out._ndr_size));
26811                         NDR_CHECK(ndr_pull_spoolss_KeyNames(_ndr_key_buffer, NDR_SCALARS|NDR_BUFFERS, r->out.key_buffer));
26812                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, *r->out._ndr_size * 2));
26813                 }
26814                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
26815                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26816                         NDR_PULL_ALLOC(ndr, r->out.needed);
26817                 }
26818                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26819                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26821                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26822                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26823         }
26824         return NDR_ERR_SUCCESS;
26825 }
26826
26827 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26828 {
26829         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26830         ndr->depth++;
26831         if (flags & NDR_SET_VALUES) {
26832                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26833         }
26834         if (flags & NDR_IN) {
26835                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26836                 ndr->depth++;
26837                 ndr_print_ptr(ndr, "handle", r->in.handle);
26838                 ndr->depth++;
26839                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26840                 ndr->depth--;
26841                 ndr_print_string(ndr, "key_name", r->in.key_name);
26842                 ndr_print_uint32(ndr, "offered", r->in.offered);
26843                 ndr->depth--;
26844         }
26845         if (flags & NDR_OUT) {
26846                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26847                 ndr->depth++;
26848                 ndr_print_ptr(ndr, "_ndr_size", r->out._ndr_size);
26849                 ndr->depth++;
26850                 ndr_print_uint32(ndr, "_ndr_size", *r->out._ndr_size);
26851                 ndr->depth--;
26852                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26853                 ndr->depth++;
26854                 ndr_print_set_switch_value(ndr, r->out.key_buffer, *r->out._ndr_size);
26855                 ndr_print_spoolss_KeyNames(ndr, "key_buffer", r->out.key_buffer);
26856                 ndr->depth--;
26857                 ndr_print_ptr(ndr, "needed", r->out.needed);
26858                 ndr->depth++;
26859                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26860                 ndr->depth--;
26861                 ndr_print_WERROR(ndr, "result", r->out.result);
26862                 ndr->depth--;
26863         }
26864         ndr->depth--;
26865 }
26866
26867 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26868 {
26869         if (flags & NDR_IN) {
26870                 if (r->in.handle == NULL) {
26871                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26872                 }
26873                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26875                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26877                 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));
26878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26879                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26880                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26881                 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));
26882         }
26883         if (flags & NDR_OUT) {
26884                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26885         }
26886         return NDR_ERR_SUCCESS;
26887 }
26888
26889 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26890 {
26891         TALLOC_CTX *_mem_save_handle_0;
26892         if (flags & NDR_IN) {
26893                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26894                         NDR_PULL_ALLOC(ndr, r->in.handle);
26895                 }
26896                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26897                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26898                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26899                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26900                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26901                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26902                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26903                         return 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));
26904                 }
26905                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26906                 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));
26907                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26908                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26909                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26910                         return 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));
26911                 }
26912                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26913                 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));
26914         }
26915         if (flags & NDR_OUT) {
26916                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26917         }
26918         return NDR_ERR_SUCCESS;
26919 }
26920
26921 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26922 {
26923         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26924         ndr->depth++;
26925         if (flags & NDR_SET_VALUES) {
26926                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26927         }
26928         if (flags & NDR_IN) {
26929                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26930                 ndr->depth++;
26931                 ndr_print_ptr(ndr, "handle", r->in.handle);
26932                 ndr->depth++;
26933                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26934                 ndr->depth--;
26935                 ndr_print_string(ndr, "key_name", r->in.key_name);
26936                 ndr_print_string(ndr, "value_name", r->in.value_name);
26937                 ndr->depth--;
26938         }
26939         if (flags & NDR_OUT) {
26940                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26941                 ndr->depth++;
26942                 ndr_print_WERROR(ndr, "result", r->out.result);
26943                 ndr->depth--;
26944         }
26945         ndr->depth--;
26946 }
26947
26948 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26949 {
26950         if (flags & NDR_IN) {
26951                 if (r->in.handle == NULL) {
26952                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26953                 }
26954                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26958                 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));
26959         }
26960         if (flags & NDR_OUT) {
26961                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26962         }
26963         return NDR_ERR_SUCCESS;
26964 }
26965
26966 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26967 {
26968         TALLOC_CTX *_mem_save_handle_0;
26969         if (flags & NDR_IN) {
26970                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26971                         NDR_PULL_ALLOC(ndr, r->in.handle);
26972                 }
26973                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26974                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26975                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26976                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26977                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26978                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26979                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26980                         return 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));
26981                 }
26982                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26983                 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));
26984         }
26985         if (flags & NDR_OUT) {
26986                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26987         }
26988         return NDR_ERR_SUCCESS;
26989 }
26990
26991 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26992 {
26993         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26994         ndr->depth++;
26995         if (flags & NDR_SET_VALUES) {
26996                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26997         }
26998         if (flags & NDR_IN) {
26999                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
27000                 ndr->depth++;
27001                 ndr_print_ptr(ndr, "handle", r->in.handle);
27002                 ndr->depth++;
27003                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27004                 ndr->depth--;
27005                 ndr_print_string(ndr, "key_name", r->in.key_name);
27006                 ndr->depth--;
27007         }
27008         if (flags & NDR_OUT) {
27009                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
27010                 ndr->depth++;
27011                 ndr_print_WERROR(ndr, "result", r->out.result);
27012                 ndr->depth--;
27013         }
27014         ndr->depth--;
27015 }
27016
27017 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
27018 {
27019         if (flags & NDR_IN) {
27020         }
27021         if (flags & NDR_OUT) {
27022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27023         }
27024         return NDR_ERR_SUCCESS;
27025 }
27026
27027 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
27028 {
27029         if (flags & NDR_IN) {
27030         }
27031         if (flags & NDR_OUT) {
27032                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27033         }
27034         return NDR_ERR_SUCCESS;
27035 }
27036
27037 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
27038 {
27039         ndr_print_struct(ndr, name, "spoolss_53");
27040         ndr->depth++;
27041         if (flags & NDR_SET_VALUES) {
27042                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27043         }
27044         if (flags & NDR_IN) {
27045                 ndr_print_struct(ndr, "in", "spoolss_53");
27046                 ndr->depth++;
27047                 ndr->depth--;
27048         }
27049         if (flags & NDR_OUT) {
27050                 ndr_print_struct(ndr, "out", "spoolss_53");
27051                 ndr->depth++;
27052                 ndr_print_WERROR(ndr, "result", r->out.result);
27053                 ndr->depth--;
27054         }
27055         ndr->depth--;
27056 }
27057
27058 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27059 {
27060         if (flags & NDR_IN) {
27061                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
27062                 if (r->in.server) {
27063                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, 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.server, CH_UTF16)));
27066                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27067                 }
27068                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27070                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
27071                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27073                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27074                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
27075                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27076                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
27077                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
27078         }
27079         if (flags & NDR_OUT) {
27080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27081         }
27082         return NDR_ERR_SUCCESS;
27083 }
27084
27085 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
27086 {
27087         uint32_t _ptr_server;
27088         TALLOC_CTX *_mem_save_server_0;
27089         if (flags & NDR_IN) {
27090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
27091                 if (_ptr_server) {
27092                         NDR_PULL_ALLOC(ndr, r->in.server);
27093                 } else {
27094                         r->in.server = NULL;
27095                 }
27096                 if (r->in.server) {
27097                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
27098                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
27099                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
27100                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
27101                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
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.server), ndr_get_array_length(ndr, &r->in.server));
27103                         }
27104                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
27105                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
27106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
27107                 }
27108                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
27109                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
27110                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
27111                         return 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));
27112                 }
27113                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
27114                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
27115                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
27116                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
27117                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
27118                         return 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));
27119                 }
27120                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
27121                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
27122                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
27123                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
27124         }
27125         if (flags & NDR_OUT) {
27126                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27127         }
27128         return NDR_ERR_SUCCESS;
27129 }
27130
27131 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27132 {
27133         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
27134         ndr->depth++;
27135         if (flags & NDR_SET_VALUES) {
27136                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27137         }
27138         if (flags & NDR_IN) {
27139                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
27140                 ndr->depth++;
27141                 ndr_print_ptr(ndr, "server", r->in.server);
27142                 ndr->depth++;
27143                 if (r->in.server) {
27144                         ndr_print_string(ndr, "server", r->in.server);
27145                 }
27146                 ndr->depth--;
27147                 ndr_print_string(ndr, "architecture", r->in.architecture);
27148                 ndr_print_string(ndr, "driver", r->in.driver);
27149                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
27150                 ndr_print_uint32(ndr, "version", r->in.version);
27151                 ndr->depth--;
27152         }
27153         if (flags & NDR_OUT) {
27154                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
27155                 ndr->depth++;
27156                 ndr_print_WERROR(ndr, "result", r->out.result);
27157                 ndr->depth--;
27158         }
27159         ndr->depth--;
27160 }
27161
27162 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
27163 {
27164         if (flags & NDR_IN) {
27165         }
27166         if (flags & NDR_OUT) {
27167                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27168         }
27169         return NDR_ERR_SUCCESS;
27170 }
27171
27172 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
27173 {
27174         if (flags & NDR_IN) {
27175         }
27176         if (flags & NDR_OUT) {
27177                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27178         }
27179         return NDR_ERR_SUCCESS;
27180 }
27181
27182 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
27183 {
27184         ndr_print_struct(ndr, name, "spoolss_55");
27185         ndr->depth++;
27186         if (flags & NDR_SET_VALUES) {
27187                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27188         }
27189         if (flags & NDR_IN) {
27190                 ndr_print_struct(ndr, "in", "spoolss_55");
27191                 ndr->depth++;
27192                 ndr->depth--;
27193         }
27194         if (flags & NDR_OUT) {
27195                 ndr_print_struct(ndr, "out", "spoolss_55");
27196                 ndr->depth++;
27197                 ndr_print_WERROR(ndr, "result", r->out.result);
27198                 ndr->depth--;
27199         }
27200         ndr->depth--;
27201 }
27202
27203 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
27204 {
27205         if (flags & NDR_IN) {
27206         }
27207         if (flags & NDR_OUT) {
27208                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27209         }
27210         return NDR_ERR_SUCCESS;
27211 }
27212
27213 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
27214 {
27215         if (flags & NDR_IN) {
27216         }
27217         if (flags & NDR_OUT) {
27218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27219         }
27220         return NDR_ERR_SUCCESS;
27221 }
27222
27223 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
27224 {
27225         ndr_print_struct(ndr, name, "spoolss_56");
27226         ndr->depth++;
27227         if (flags & NDR_SET_VALUES) {
27228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27229         }
27230         if (flags & NDR_IN) {
27231                 ndr_print_struct(ndr, "in", "spoolss_56");
27232                 ndr->depth++;
27233                 ndr->depth--;
27234         }
27235         if (flags & NDR_OUT) {
27236                 ndr_print_struct(ndr, "out", "spoolss_56");
27237                 ndr->depth++;
27238                 ndr_print_WERROR(ndr, "result", r->out.result);
27239                 ndr->depth--;
27240         }
27241         ndr->depth--;
27242 }
27243
27244 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
27245 {
27246         if (flags & NDR_IN) {
27247         }
27248         if (flags & NDR_OUT) {
27249                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27250         }
27251         return NDR_ERR_SUCCESS;
27252 }
27253
27254 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
27255 {
27256         if (flags & NDR_IN) {
27257         }
27258         if (flags & NDR_OUT) {
27259                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27260         }
27261         return NDR_ERR_SUCCESS;
27262 }
27263
27264 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
27265 {
27266         ndr_print_struct(ndr, name, "spoolss_57");
27267         ndr->depth++;
27268         if (flags & NDR_SET_VALUES) {
27269                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27270         }
27271         if (flags & NDR_IN) {
27272                 ndr_print_struct(ndr, "in", "spoolss_57");
27273                 ndr->depth++;
27274                 ndr->depth--;
27275         }
27276         if (flags & NDR_OUT) {
27277                 ndr_print_struct(ndr, "out", "spoolss_57");
27278                 ndr->depth++;
27279                 ndr_print_WERROR(ndr, "result", r->out.result);
27280                 ndr->depth--;
27281         }
27282         ndr->depth--;
27283 }
27284
27285 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
27286 {
27287         if (flags & NDR_IN) {
27288                 if (r->in.handle == NULL) {
27289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27290                 }
27291                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27295                 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));
27296                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
27297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
27298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27299                 if (r->in.status_code == NULL) {
27300                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27301                 }
27302                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
27303         }
27304         if (flags & NDR_OUT) {
27305                 if (r->out.out_data == 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->in.out_data_size));
27309                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
27310                 if (r->out.needed == NULL) {
27311                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27312                 }
27313                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27314                 if (r->out.status_code == NULL) {
27315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27316                 }
27317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
27318                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27319         }
27320         return NDR_ERR_SUCCESS;
27321 }
27322
27323 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
27324 {
27325         TALLOC_CTX *_mem_save_handle_0;
27326         TALLOC_CTX *_mem_save_needed_0;
27327         TALLOC_CTX *_mem_save_status_code_0;
27328         if (flags & NDR_IN) {
27329                 ZERO_STRUCT(r->out);
27330
27331                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27332                         NDR_PULL_ALLOC(ndr, r->in.handle);
27333                 }
27334                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27335                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27336                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27337                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27338                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
27339                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
27340                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
27341                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.function_name), ndr_get_array_length(ndr, &r->in.function_name));
27342                 }
27343                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
27344                 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));
27345                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
27346                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
27347                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
27348                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27349                         NDR_PULL_ALLOC(ndr, r->in.status_code);
27350                 }
27351                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27352                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
27353                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
27354                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27355                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
27356                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
27357                 NDR_PULL_ALLOC(ndr, r->out.needed);
27358                 ZERO_STRUCTP(r->out.needed);
27359                 NDR_PULL_ALLOC(ndr, r->out.status_code);
27360                 *r->out.status_code = *r->in.status_code;
27361         }
27362         if (flags & NDR_OUT) {
27363                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
27364                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27365                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
27366                 }
27367                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
27368                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27369                         NDR_PULL_ALLOC(ndr, r->out.needed);
27370                 }
27371                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27372                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27374                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27375                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27376                         NDR_PULL_ALLOC(ndr, r->out.status_code);
27377                 }
27378                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27379                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
27380                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
27381                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27382                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27383                 if (r->out.out_data) {
27384                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
27385                 }
27386         }
27387         return NDR_ERR_SUCCESS;
27388 }
27389
27390 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
27391 {
27392         ndr_print_struct(ndr, name, "spoolss_XcvData");
27393         ndr->depth++;
27394         if (flags & NDR_SET_VALUES) {
27395                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27396         }
27397         if (flags & NDR_IN) {
27398                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
27399                 ndr->depth++;
27400                 ndr_print_ptr(ndr, "handle", r->in.handle);
27401                 ndr->depth++;
27402                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27403                 ndr->depth--;
27404                 ndr_print_string(ndr, "function_name", r->in.function_name);
27405                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
27406                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
27407                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
27408                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
27409                 ndr->depth++;
27410                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
27411                 ndr->depth--;
27412                 ndr->depth--;
27413         }
27414         if (flags & NDR_OUT) {
27415                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
27416                 ndr->depth++;
27417                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
27418                 ndr->depth++;
27419                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
27420                 ndr->depth--;
27421                 ndr_print_ptr(ndr, "needed", r->out.needed);
27422                 ndr->depth++;
27423                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27424                 ndr->depth--;
27425                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
27426                 ndr->depth++;
27427                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
27428                 ndr->depth--;
27429                 ndr_print_WERROR(ndr, "result", r->out.result);
27430                 ndr->depth--;
27431         }
27432         ndr->depth--;
27433 }
27434
27435 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
27436 {
27437         if (flags & NDR_IN) {
27438                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
27439                 if (r->in.servername) {
27440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27444                 }
27445                 if (r->in.info_ctr == NULL) {
27446                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27447                 }
27448                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27449                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
27450         }
27451         if (flags & NDR_OUT) {
27452                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27453         }
27454         return NDR_ERR_SUCCESS;
27455 }
27456
27457 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
27458 {
27459         uint32_t _ptr_servername;
27460         TALLOC_CTX *_mem_save_servername_0;
27461         TALLOC_CTX *_mem_save_info_ctr_0;
27462         if (flags & NDR_IN) {
27463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
27464                 if (_ptr_servername) {
27465                         NDR_PULL_ALLOC(ndr, r->in.servername);
27466                 } else {
27467                         r->in.servername = NULL;
27468                 }
27469                 if (r->in.servername) {
27470                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27471                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
27472                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
27473                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
27474                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
27475                                 return 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));
27476                         }
27477                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
27478                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
27479                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
27480                 }
27481                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27482                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27483                 }
27484                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27485                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27486                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27487                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27488                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27489         }
27490         if (flags & NDR_OUT) {
27491                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27492         }
27493         return NDR_ERR_SUCCESS;
27494 }
27495
27496 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27497 {
27498         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27499         ndr->depth++;
27500         if (flags & NDR_SET_VALUES) {
27501                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27502         }
27503         if (flags & NDR_IN) {
27504                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27505                 ndr->depth++;
27506                 ndr_print_ptr(ndr, "servername", r->in.servername);
27507                 ndr->depth++;
27508                 if (r->in.servername) {
27509                         ndr_print_string(ndr, "servername", r->in.servername);
27510                 }
27511                 ndr->depth--;
27512                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27513                 ndr->depth++;
27514                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27515                 ndr->depth--;
27516                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
27517                 ndr->depth--;
27518         }
27519         if (flags & NDR_OUT) {
27520                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
27521                 ndr->depth++;
27522                 ndr_print_WERROR(ndr, "result", r->out.result);
27523                 ndr->depth--;
27524         }
27525         ndr->depth--;
27526 }
27527
27528 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
27529 {
27530         if (flags & NDR_IN) {
27531         }
27532         if (flags & NDR_OUT) {
27533                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27534         }
27535         return NDR_ERR_SUCCESS;
27536 }
27537
27538 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27539 {
27540         if (flags & NDR_IN) {
27541         }
27542         if (flags & NDR_OUT) {
27543                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27544         }
27545         return NDR_ERR_SUCCESS;
27546 }
27547
27548 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27549 {
27550         ndr_print_struct(ndr, name, "spoolss_5a");
27551         ndr->depth++;
27552         if (flags & NDR_SET_VALUES) {
27553                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27554         }
27555         if (flags & NDR_IN) {
27556                 ndr_print_struct(ndr, "in", "spoolss_5a");
27557                 ndr->depth++;
27558                 ndr->depth--;
27559         }
27560         if (flags & NDR_OUT) {
27561                 ndr_print_struct(ndr, "out", "spoolss_5a");
27562                 ndr->depth++;
27563                 ndr_print_WERROR(ndr, "result", r->out.result);
27564                 ndr->depth--;
27565         }
27566         ndr->depth--;
27567 }
27568
27569 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27570 {
27571         if (flags & NDR_IN) {
27572         }
27573         if (flags & NDR_OUT) {
27574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27575         }
27576         return NDR_ERR_SUCCESS;
27577 }
27578
27579 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27580 {
27581         if (flags & NDR_IN) {
27582         }
27583         if (flags & NDR_OUT) {
27584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27585         }
27586         return NDR_ERR_SUCCESS;
27587 }
27588
27589 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27590 {
27591         ndr_print_struct(ndr, name, "spoolss_5b");
27592         ndr->depth++;
27593         if (flags & NDR_SET_VALUES) {
27594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27595         }
27596         if (flags & NDR_IN) {
27597                 ndr_print_struct(ndr, "in", "spoolss_5b");
27598                 ndr->depth++;
27599                 ndr->depth--;
27600         }
27601         if (flags & NDR_OUT) {
27602                 ndr_print_struct(ndr, "out", "spoolss_5b");
27603                 ndr->depth++;
27604                 ndr_print_WERROR(ndr, "result", r->out.result);
27605                 ndr->depth--;
27606         }
27607         ndr->depth--;
27608 }
27609
27610 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27611 {
27612         if (flags & NDR_IN) {
27613         }
27614         if (flags & NDR_OUT) {
27615                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27616         }
27617         return NDR_ERR_SUCCESS;
27618 }
27619
27620 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27621 {
27622         if (flags & NDR_IN) {
27623         }
27624         if (flags & NDR_OUT) {
27625                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27626         }
27627         return NDR_ERR_SUCCESS;
27628 }
27629
27630 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27631 {
27632         ndr_print_struct(ndr, name, "spoolss_5c");
27633         ndr->depth++;
27634         if (flags & NDR_SET_VALUES) {
27635                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27636         }
27637         if (flags & NDR_IN) {
27638                 ndr_print_struct(ndr, "in", "spoolss_5c");
27639                 ndr->depth++;
27640                 ndr->depth--;
27641         }
27642         if (flags & NDR_OUT) {
27643                 ndr_print_struct(ndr, "out", "spoolss_5c");
27644                 ndr->depth++;
27645                 ndr_print_WERROR(ndr, "result", r->out.result);
27646                 ndr->depth--;
27647         }
27648         ndr->depth--;
27649 }
27650
27651 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27652 {
27653         if (flags & NDR_IN) {
27654         }
27655         if (flags & NDR_OUT) {
27656                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27657         }
27658         return NDR_ERR_SUCCESS;
27659 }
27660
27661 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27662 {
27663         if (flags & NDR_IN) {
27664         }
27665         if (flags & NDR_OUT) {
27666                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27667         }
27668         return NDR_ERR_SUCCESS;
27669 }
27670
27671 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27672 {
27673         ndr_print_struct(ndr, name, "spoolss_5d");
27674         ndr->depth++;
27675         if (flags & NDR_SET_VALUES) {
27676                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27677         }
27678         if (flags & NDR_IN) {
27679                 ndr_print_struct(ndr, "in", "spoolss_5d");
27680                 ndr->depth++;
27681                 ndr->depth--;
27682         }
27683         if (flags & NDR_OUT) {
27684                 ndr_print_struct(ndr, "out", "spoolss_5d");
27685                 ndr->depth++;
27686                 ndr_print_WERROR(ndr, "result", r->out.result);
27687                 ndr->depth--;
27688         }
27689         ndr->depth--;
27690 }
27691
27692 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27693 {
27694         if (flags & NDR_IN) {
27695         }
27696         if (flags & NDR_OUT) {
27697                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27698         }
27699         return NDR_ERR_SUCCESS;
27700 }
27701
27702 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27703 {
27704         if (flags & NDR_IN) {
27705         }
27706         if (flags & NDR_OUT) {
27707                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27708         }
27709         return NDR_ERR_SUCCESS;
27710 }
27711
27712 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27713 {
27714         ndr_print_struct(ndr, name, "spoolss_5e");
27715         ndr->depth++;
27716         if (flags & NDR_SET_VALUES) {
27717                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27718         }
27719         if (flags & NDR_IN) {
27720                 ndr_print_struct(ndr, "in", "spoolss_5e");
27721                 ndr->depth++;
27722                 ndr->depth--;
27723         }
27724         if (flags & NDR_OUT) {
27725                 ndr_print_struct(ndr, "out", "spoolss_5e");
27726                 ndr->depth++;
27727                 ndr_print_WERROR(ndr, "result", r->out.result);
27728                 ndr->depth--;
27729         }
27730         ndr->depth--;
27731 }
27732
27733 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27734 {
27735         if (flags & NDR_IN) {
27736         }
27737         if (flags & NDR_OUT) {
27738                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27739         }
27740         return NDR_ERR_SUCCESS;
27741 }
27742
27743 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27744 {
27745         if (flags & NDR_IN) {
27746         }
27747         if (flags & NDR_OUT) {
27748                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27749         }
27750         return NDR_ERR_SUCCESS;
27751 }
27752
27753 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27754 {
27755         ndr_print_struct(ndr, name, "spoolss_5f");
27756         ndr->depth++;
27757         if (flags & NDR_SET_VALUES) {
27758                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27759         }
27760         if (flags & NDR_IN) {
27761                 ndr_print_struct(ndr, "in", "spoolss_5f");
27762                 ndr->depth++;
27763                 ndr->depth--;
27764         }
27765         if (flags & NDR_OUT) {
27766                 ndr_print_struct(ndr, "out", "spoolss_5f");
27767                 ndr->depth++;
27768                 ndr_print_WERROR(ndr, "result", r->out.result);
27769                 ndr->depth--;
27770         }
27771         ndr->depth--;
27772 }
27773
27774 static const struct ndr_interface_call spoolss_calls[] = {
27775         {
27776                 "spoolss_EnumPrinters",
27777                 sizeof(struct spoolss_EnumPrinters),
27778                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27779                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27780                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27781                 false,
27782         },
27783         {
27784                 "spoolss_OpenPrinter",
27785                 sizeof(struct spoolss_OpenPrinter),
27786                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27787                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27788                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27789                 false,
27790         },
27791         {
27792                 "spoolss_SetJob",
27793                 sizeof(struct spoolss_SetJob),
27794                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27795                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27796                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27797                 false,
27798         },
27799         {
27800                 "spoolss_GetJob",
27801                 sizeof(struct spoolss_GetJob),
27802                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27803                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27804                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27805                 false,
27806         },
27807         {
27808                 "spoolss_EnumJobs",
27809                 sizeof(struct spoolss_EnumJobs),
27810                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27811                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27812                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27813                 false,
27814         },
27815         {
27816                 "spoolss_AddPrinter",
27817                 sizeof(struct spoolss_AddPrinter),
27818                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27819                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27820                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27821                 false,
27822         },
27823         {
27824                 "spoolss_DeletePrinter",
27825                 sizeof(struct spoolss_DeletePrinter),
27826                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27827                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27828                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27829                 false,
27830         },
27831         {
27832                 "spoolss_SetPrinter",
27833                 sizeof(struct spoolss_SetPrinter),
27834                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27835                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27836                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27837                 false,
27838         },
27839         {
27840                 "spoolss_GetPrinter",
27841                 sizeof(struct spoolss_GetPrinter),
27842                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27843                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27844                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27845                 false,
27846         },
27847         {
27848                 "spoolss_AddPrinterDriver",
27849                 sizeof(struct spoolss_AddPrinterDriver),
27850                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27851                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27852                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27853                 false,
27854         },
27855         {
27856                 "spoolss_EnumPrinterDrivers",
27857                 sizeof(struct spoolss_EnumPrinterDrivers),
27858                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27859                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27860                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27861                 false,
27862         },
27863         {
27864                 "spoolss_GetPrinterDriver",
27865                 sizeof(struct spoolss_GetPrinterDriver),
27866                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27867                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27868                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27869                 false,
27870         },
27871         {
27872                 "spoolss_GetPrinterDriverDirectory",
27873                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27874                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27875                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27876                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27877                 false,
27878         },
27879         {
27880                 "spoolss_DeletePrinterDriver",
27881                 sizeof(struct spoolss_DeletePrinterDriver),
27882                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27883                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27884                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27885                 false,
27886         },
27887         {
27888                 "spoolss_AddPrintProcessor",
27889                 sizeof(struct spoolss_AddPrintProcessor),
27890                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27891                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27892                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27893                 false,
27894         },
27895         {
27896                 "spoolss_EnumPrintProcessors",
27897                 sizeof(struct spoolss_EnumPrintProcessors),
27898                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27899                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27900                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27901                 false,
27902         },
27903         {
27904                 "spoolss_GetPrintProcessorDirectory",
27905                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27906                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27907                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27908                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27909                 false,
27910         },
27911         {
27912                 "spoolss_StartDocPrinter",
27913                 sizeof(struct spoolss_StartDocPrinter),
27914                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27915                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27916                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27917                 false,
27918         },
27919         {
27920                 "spoolss_StartPagePrinter",
27921                 sizeof(struct spoolss_StartPagePrinter),
27922                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27923                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27924                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27925                 false,
27926         },
27927         {
27928                 "spoolss_WritePrinter",
27929                 sizeof(struct spoolss_WritePrinter),
27930                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27931                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27932                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27933                 false,
27934         },
27935         {
27936                 "spoolss_EndPagePrinter",
27937                 sizeof(struct spoolss_EndPagePrinter),
27938                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27939                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27940                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27941                 false,
27942         },
27943         {
27944                 "spoolss_AbortPrinter",
27945                 sizeof(struct spoolss_AbortPrinter),
27946                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27947                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27948                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27949                 false,
27950         },
27951         {
27952                 "spoolss_ReadPrinter",
27953                 sizeof(struct spoolss_ReadPrinter),
27954                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27955                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27956                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27957                 false,
27958         },
27959         {
27960                 "spoolss_EndDocPrinter",
27961                 sizeof(struct spoolss_EndDocPrinter),
27962                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27963                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27964                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27965                 false,
27966         },
27967         {
27968                 "spoolss_AddJob",
27969                 sizeof(struct spoolss_AddJob),
27970                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27971                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27972                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27973                 false,
27974         },
27975         {
27976                 "spoolss_ScheduleJob",
27977                 sizeof(struct spoolss_ScheduleJob),
27978                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27979                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27980                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27981                 false,
27982         },
27983         {
27984                 "spoolss_GetPrinterData",
27985                 sizeof(struct spoolss_GetPrinterData),
27986                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27987                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27988                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27989                 false,
27990         },
27991         {
27992                 "spoolss_SetPrinterData",
27993                 sizeof(struct spoolss_SetPrinterData),
27994                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27995                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27996                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27997                 false,
27998         },
27999         {
28000                 "spoolss_WaitForPrinterChange",
28001                 sizeof(struct spoolss_WaitForPrinterChange),
28002                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
28003                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
28004                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
28005                 false,
28006         },
28007         {
28008                 "spoolss_ClosePrinter",
28009                 sizeof(struct spoolss_ClosePrinter),
28010                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
28011                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
28012                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
28013                 false,
28014         },
28015         {
28016                 "spoolss_AddForm",
28017                 sizeof(struct spoolss_AddForm),
28018                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
28019                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
28020                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
28021                 false,
28022         },
28023         {
28024                 "spoolss_DeleteForm",
28025                 sizeof(struct spoolss_DeleteForm),
28026                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
28027                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
28028                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
28029                 false,
28030         },
28031         {
28032                 "spoolss_GetForm",
28033                 sizeof(struct spoolss_GetForm),
28034                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
28035                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
28036                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
28037                 false,
28038         },
28039         {
28040                 "spoolss_SetForm",
28041                 sizeof(struct spoolss_SetForm),
28042                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
28043                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
28044                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
28045                 false,
28046         },
28047         {
28048                 "spoolss_EnumForms",
28049                 sizeof(struct spoolss_EnumForms),
28050                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
28051                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
28052                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
28053                 false,
28054         },
28055         {
28056                 "spoolss_EnumPorts",
28057                 sizeof(struct spoolss_EnumPorts),
28058                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
28059                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
28060                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
28061                 false,
28062         },
28063         {
28064                 "spoolss_EnumMonitors",
28065                 sizeof(struct spoolss_EnumMonitors),
28066                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
28067                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
28068                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
28069                 false,
28070         },
28071         {
28072                 "spoolss_AddPort",
28073                 sizeof(struct spoolss_AddPort),
28074                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
28075                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
28076                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
28077                 false,
28078         },
28079         {
28080                 "spoolss_ConfigurePort",
28081                 sizeof(struct spoolss_ConfigurePort),
28082                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
28083                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
28084                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
28085                 false,
28086         },
28087         {
28088                 "spoolss_DeletePort",
28089                 sizeof(struct spoolss_DeletePort),
28090                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
28091                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
28092                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
28093                 false,
28094         },
28095         {
28096                 "spoolss_CreatePrinterIC",
28097                 sizeof(struct spoolss_CreatePrinterIC),
28098                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
28099                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
28100                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
28101                 false,
28102         },
28103         {
28104                 "spoolss_PlayGDIScriptOnPrinterIC",
28105                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
28106                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
28107                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
28108                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
28109                 false,
28110         },
28111         {
28112                 "spoolss_DeletePrinterIC",
28113                 sizeof(struct spoolss_DeletePrinterIC),
28114                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
28115                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
28116                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
28117                 false,
28118         },
28119         {
28120                 "spoolss_AddPrinterConnection",
28121                 sizeof(struct spoolss_AddPrinterConnection),
28122                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
28123                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
28124                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
28125                 false,
28126         },
28127         {
28128                 "spoolss_DeletePrinterConnection",
28129                 sizeof(struct spoolss_DeletePrinterConnection),
28130                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
28131                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
28132                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
28133                 false,
28134         },
28135         {
28136                 "spoolss_PrinterMessageBox",
28137                 sizeof(struct spoolss_PrinterMessageBox),
28138                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
28139                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
28140                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
28141                 false,
28142         },
28143         {
28144                 "spoolss_AddMonitor",
28145                 sizeof(struct spoolss_AddMonitor),
28146                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
28147                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
28148                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
28149                 false,
28150         },
28151         {
28152                 "spoolss_DeleteMonitor",
28153                 sizeof(struct spoolss_DeleteMonitor),
28154                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
28155                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
28156                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
28157                 false,
28158         },
28159         {
28160                 "spoolss_DeletePrintProcessor",
28161                 sizeof(struct spoolss_DeletePrintProcessor),
28162                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
28163                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
28164                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
28165                 false,
28166         },
28167         {
28168                 "spoolss_AddPrintProvidor",
28169                 sizeof(struct spoolss_AddPrintProvidor),
28170                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
28171                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
28172                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
28173                 false,
28174         },
28175         {
28176                 "spoolss_DeletePrintProvidor",
28177                 sizeof(struct spoolss_DeletePrintProvidor),
28178                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
28179                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
28180                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
28181                 false,
28182         },
28183         {
28184                 "spoolss_EnumPrintProcDataTypes",
28185                 sizeof(struct spoolss_EnumPrintProcDataTypes),
28186                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
28187                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
28188                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
28189                 false,
28190         },
28191         {
28192                 "spoolss_ResetPrinter",
28193                 sizeof(struct spoolss_ResetPrinter),
28194                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
28195                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
28196                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
28197                 false,
28198         },
28199         {
28200                 "spoolss_GetPrinterDriver2",
28201                 sizeof(struct spoolss_GetPrinterDriver2),
28202                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
28203                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
28204                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
28205                 false,
28206         },
28207         {
28208                 "spoolss_FindFirstPrinterChangeNotification",
28209                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
28210                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
28211                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
28212                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
28213                 false,
28214         },
28215         {
28216                 "spoolss_FindNextPrinterChangeNotification",
28217                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
28218                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
28219                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
28220                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
28221                 false,
28222         },
28223         {
28224                 "spoolss_FindClosePrinterNotify",
28225                 sizeof(struct spoolss_FindClosePrinterNotify),
28226                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
28227                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
28228                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
28229                 false,
28230         },
28231         {
28232                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
28233                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
28234                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28235                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28236                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28237                 false,
28238         },
28239         {
28240                 "spoolss_ReplyOpenPrinter",
28241                 sizeof(struct spoolss_ReplyOpenPrinter),
28242                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
28243                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
28244                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
28245                 false,
28246         },
28247         {
28248                 "spoolss_RouterReplyPrinter",
28249                 sizeof(struct spoolss_RouterReplyPrinter),
28250                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
28251                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
28252                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
28253                 false,
28254         },
28255         {
28256                 "spoolss_ReplyClosePrinter",
28257                 sizeof(struct spoolss_ReplyClosePrinter),
28258                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
28259                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
28260                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
28261                 false,
28262         },
28263         {
28264                 "spoolss_AddPortEx",
28265                 sizeof(struct spoolss_AddPortEx),
28266                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
28267                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
28268                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
28269                 false,
28270         },
28271         {
28272                 "spoolss_RouterFindFirstPrinterChangeNotification",
28273                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
28274                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
28275                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
28276                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
28277                 false,
28278         },
28279         {
28280                 "spoolss_SpoolerInit",
28281                 sizeof(struct spoolss_SpoolerInit),
28282                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
28283                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
28284                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
28285                 false,
28286         },
28287         {
28288                 "spoolss_ResetPrinterEx",
28289                 sizeof(struct spoolss_ResetPrinterEx),
28290                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
28291                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
28292                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
28293                 false,
28294         },
28295         {
28296                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
28297                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
28298                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28299                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28300                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28301                 false,
28302         },
28303         {
28304                 "spoolss_RouterReplyPrinterEx",
28305                 sizeof(struct spoolss_RouterReplyPrinterEx),
28306                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
28307                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
28308                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
28309                 false,
28310         },
28311         {
28312                 "spoolss_RouterRefreshPrinterChangeNotify",
28313                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
28314                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
28315                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
28316                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
28317                 false,
28318         },
28319         {
28320                 "spoolss_44",
28321                 sizeof(struct spoolss_44),
28322                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
28323                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
28324                 (ndr_print_function_t) ndr_print_spoolss_44,
28325                 false,
28326         },
28327         {
28328                 "spoolss_OpenPrinterEx",
28329                 sizeof(struct spoolss_OpenPrinterEx),
28330                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
28331                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
28332                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
28333                 false,
28334         },
28335         {
28336                 "spoolss_AddPrinterEx",
28337                 sizeof(struct spoolss_AddPrinterEx),
28338                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
28339                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
28340                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
28341                 false,
28342         },
28343         {
28344                 "spoolss_47",
28345                 sizeof(struct spoolss_47),
28346                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
28347                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
28348                 (ndr_print_function_t) ndr_print_spoolss_47,
28349                 false,
28350         },
28351         {
28352                 "spoolss_EnumPrinterData",
28353                 sizeof(struct spoolss_EnumPrinterData),
28354                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
28355                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
28356                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
28357                 false,
28358         },
28359         {
28360                 "spoolss_DeletePrinterData",
28361                 sizeof(struct spoolss_DeletePrinterData),
28362                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
28363                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
28364                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
28365                 false,
28366         },
28367         {
28368                 "spoolss_4a",
28369                 sizeof(struct spoolss_4a),
28370                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
28371                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
28372                 (ndr_print_function_t) ndr_print_spoolss_4a,
28373                 false,
28374         },
28375         {
28376                 "spoolss_4b",
28377                 sizeof(struct spoolss_4b),
28378                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
28379                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
28380                 (ndr_print_function_t) ndr_print_spoolss_4b,
28381                 false,
28382         },
28383         {
28384                 "spoolss_4c",
28385                 sizeof(struct spoolss_4c),
28386                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
28387                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
28388                 (ndr_print_function_t) ndr_print_spoolss_4c,
28389                 false,
28390         },
28391         {
28392                 "spoolss_SetPrinterDataEx",
28393                 sizeof(struct spoolss_SetPrinterDataEx),
28394                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
28395                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
28396                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
28397                 false,
28398         },
28399         {
28400                 "spoolss_GetPrinterDataEx",
28401                 sizeof(struct spoolss_GetPrinterDataEx),
28402                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
28403                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
28404                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
28405                 false,
28406         },
28407         {
28408                 "spoolss_EnumPrinterDataEx",
28409                 sizeof(struct spoolss_EnumPrinterDataEx),
28410                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
28411                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
28412                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
28413                 false,
28414         },
28415         {
28416                 "spoolss_EnumPrinterKey",
28417                 sizeof(struct spoolss_EnumPrinterKey),
28418                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
28419                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
28420                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
28421                 false,
28422         },
28423         {
28424                 "spoolss_DeletePrinterDataEx",
28425                 sizeof(struct spoolss_DeletePrinterDataEx),
28426                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
28427                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
28428                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
28429                 false,
28430         },
28431         {
28432                 "spoolss_DeletePrinterKey",
28433                 sizeof(struct spoolss_DeletePrinterKey),
28434                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
28435                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
28436                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
28437                 false,
28438         },
28439         {
28440                 "spoolss_53",
28441                 sizeof(struct spoolss_53),
28442                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
28443                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
28444                 (ndr_print_function_t) ndr_print_spoolss_53,
28445                 false,
28446         },
28447         {
28448                 "spoolss_DeletePrinterDriverEx",
28449                 sizeof(struct spoolss_DeletePrinterDriverEx),
28450                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
28451                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
28452                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
28453                 false,
28454         },
28455         {
28456                 "spoolss_55",
28457                 sizeof(struct spoolss_55),
28458                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
28459                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
28460                 (ndr_print_function_t) ndr_print_spoolss_55,
28461                 false,
28462         },
28463         {
28464                 "spoolss_56",
28465                 sizeof(struct spoolss_56),
28466                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
28467                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
28468                 (ndr_print_function_t) ndr_print_spoolss_56,
28469                 false,
28470         },
28471         {
28472                 "spoolss_57",
28473                 sizeof(struct spoolss_57),
28474                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
28475                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
28476                 (ndr_print_function_t) ndr_print_spoolss_57,
28477                 false,
28478         },
28479         {
28480                 "spoolss_XcvData",
28481                 sizeof(struct spoolss_XcvData),
28482                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
28483                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
28484                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
28485                 false,
28486         },
28487         {
28488                 "spoolss_AddPrinterDriverEx",
28489                 sizeof(struct spoolss_AddPrinterDriverEx),
28490                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28491                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28492                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28493                 false,
28494         },
28495         {
28496                 "spoolss_5a",
28497                 sizeof(struct spoolss_5a),
28498                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28499                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28500                 (ndr_print_function_t) ndr_print_spoolss_5a,
28501                 false,
28502         },
28503         {
28504                 "spoolss_5b",
28505                 sizeof(struct spoolss_5b),
28506                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28507                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28508                 (ndr_print_function_t) ndr_print_spoolss_5b,
28509                 false,
28510         },
28511         {
28512                 "spoolss_5c",
28513                 sizeof(struct spoolss_5c),
28514                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
28515                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
28516                 (ndr_print_function_t) ndr_print_spoolss_5c,
28517                 false,
28518         },
28519         {
28520                 "spoolss_5d",
28521                 sizeof(struct spoolss_5d),
28522                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
28523                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
28524                 (ndr_print_function_t) ndr_print_spoolss_5d,
28525                 false,
28526         },
28527         {
28528                 "spoolss_5e",
28529                 sizeof(struct spoolss_5e),
28530                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
28531                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28532                 (ndr_print_function_t) ndr_print_spoolss_5e,
28533                 false,
28534         },
28535         {
28536                 "spoolss_5f",
28537                 sizeof(struct spoolss_5f),
28538                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28539                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28540                 (ndr_print_function_t) ndr_print_spoolss_5f,
28541                 false,
28542         },
28543         { NULL, 0, NULL, NULL, NULL, false }
28544 };
28545
28546 static const char * const spoolss_endpoint_strings[] = {
28547         "ncacn_np:[\\pipe\\spoolss]",
28548 };
28549
28550 static const struct ndr_interface_string_array spoolss_endpoints = {
28551         .count  = 1,
28552         .names  = spoolss_endpoint_strings
28553 };
28554
28555 static const char * const spoolss_authservice_strings[] = {
28556         "host",
28557 };
28558
28559 static const struct ndr_interface_string_array spoolss_authservices = {
28560         .count  = 1,
28561         .names  = spoolss_authservice_strings
28562 };
28563
28564
28565 const struct ndr_interface_table ndr_table_spoolss = {
28566         .name           = "spoolss",
28567         .syntax_id      = {
28568                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28569                 NDR_SPOOLSS_VERSION
28570         },
28571         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28572         .num_calls      = 96,
28573         .calls          = spoolss_calls,
28574         .endpoints      = &spoolss_endpoints,
28575         .authservices   = &spoolss_authservices
28576 };
28577