librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 4));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 516 {
 517         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 518 }
 519
 520 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 521 {
 522         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 527 {
 528         uint32_t v;
 529         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 530         *r = v;
 531         return NDR_ERR_SUCCESS;
 532 }
 533
 534 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 535 {
 536         ndr_print_uint32(ndr, name, r);
 537         ndr->depth++;
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 566         ndr->depth--;
 567 }
 568
 569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 570 {
 571         if (ndr_flags & NDR_SCALARS) {
 572                 NDR_CHECK(ndr_push_align(ndr, 4));
 573                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 578                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 587                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 589                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 590                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 591                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 592                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 593                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 607                 {
 608                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 610                         {
 611                                 struct ndr_push *_ndr_driverextra_data;
 612                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 613                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 614                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 615                         }
 616                         ndr->flags = _flags_save_DATA_BLOB;
 617                 }
 618         }
 619         if (ndr_flags & NDR_BUFFERS) {
 620         }
 621         return NDR_ERR_SUCCESS;
 622 }
 623
 624 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 625 {
 626         if (ndr_flags & NDR_SCALARS) {
 627                 NDR_CHECK(ndr_pull_align(ndr, 4));
 628                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 633                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 642                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 644                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 645                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 646                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 647                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 648                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 662                 {
 663                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 665                         {
 666                                 struct ndr_pull *_ndr_driverextra_data;
 667                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 668                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 669                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 670                         }
 671                         ndr->flags = _flags_save_DATA_BLOB;
 672                 }
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675         }
 676         return NDR_ERR_SUCCESS;
 677 }
 678
 679 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 680 {
 681         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 682         ndr->depth++;
 683         ndr_print_string(ndr, "devicename", r->devicename);
 684         ndr_print_uint16(ndr, "specversion", r->specversion);
 685         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 686         ndr_print_uint16(ndr, "size", r->size);
 687         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 688         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 689         ndr_print_uint16(ndr, "orientation", r->orientation);
 690         ndr_print_uint16(ndr, "papersize", r->papersize);
 691         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 692         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 693         ndr_print_uint16(ndr, "scale", r->scale);
 694         ndr_print_uint16(ndr, "copies", r->copies);
 695         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 696         ndr_print_uint16(ndr, "printquality", r->printquality);
 697         ndr_print_uint16(ndr, "color", r->color);
 698         ndr_print_uint16(ndr, "duplex", r->duplex);
 699         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 700         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 701         ndr_print_uint16(ndr, "collate", r->collate);
 702         ndr_print_string(ndr, "formname", r->formname);
 703         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 704         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 705         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 706         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 707         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 708         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 709         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 710         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 711         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 712         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 713         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 714         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 715         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 716         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 717         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 718         ndr->depth--;
 719 }
 720
 721 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 722 {
 723         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 724 }
 725
 726 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 727 {
 728         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 729         return NDR_ERR_SUCCESS;
 730 }
 731
 732 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 733 {
 734         uint32_t v;
 735         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 736         *r = v;
 737         return NDR_ERR_SUCCESS;
 738 }
 739
 740 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 741 {
 742         ndr_print_uint32(ndr, name, r);
 743         ndr->depth++;
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 759         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 763         ndr->depth--;
 764 }
 765
 766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_push_align(ndr, 4));
 770                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 771                 {
 772                         uint32_t _flags_save_string = ndr->flags;
 773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 774                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 775                         ndr->flags = _flags_save_string;
 776                 }
 777                 {
 778                         uint32_t _flags_save_string = ndr->flags;
 779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 780                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 781                         ndr->flags = _flags_save_string;
 782                 }
 783                 {
 784                         uint32_t _flags_save_string = ndr->flags;
 785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 786                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 787                         ndr->flags = _flags_save_string;
 788                 }
 789         }
 790         if (ndr_flags & NDR_BUFFERS) {
 791                 {
 792                         uint32_t _flags_save_string = ndr->flags;
 793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 794                         if (r->description) {
 795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 797                         }
 798                         ndr->flags = _flags_save_string;
 799                 }
 800                 {
 801                         uint32_t _flags_save_string = ndr->flags;
 802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 803                         if (r->name) {
 804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 806                         }
 807                         ndr->flags = _flags_save_string;
 808                 }
 809                 {
 810                         uint32_t _flags_save_string = ndr->flags;
 811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 812                         if (r->comment) {
 813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 814                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 815                         }
 816                         ndr->flags = _flags_save_string;
 817                 }
 818         }
 819         return NDR_ERR_SUCCESS;
 820 }
 821
 822 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 823 {
 824         uint32_t _ptr_description;
 825         TALLOC_CTX *_mem_save_description_0;
 826         uint32_t _ptr_name;
 827         TALLOC_CTX *_mem_save_name_0;
 828         uint32_t _ptr_comment;
 829         TALLOC_CTX *_mem_save_comment_0;
 830         if (ndr_flags & NDR_SCALARS) {
 831                 NDR_CHECK(ndr_pull_align(ndr, 4));
 832                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 833                 {
 834                         uint32_t _flags_save_string = ndr->flags;
 835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 837                         if (_ptr_description) {
 838                                 NDR_PULL_ALLOC(ndr, r->description);
 839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 840                         } else {
 841                                 r->description = NULL;
 842                         }
 843                         ndr->flags = _flags_save_string;
 844                 }
 845                 {
 846                         uint32_t _flags_save_string = ndr->flags;
 847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 849                         if (_ptr_name) {
 850                                 NDR_PULL_ALLOC(ndr, r->name);
 851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 852                         } else {
 853                                 r->name = NULL;
 854                         }
 855                         ndr->flags = _flags_save_string;
 856                 }
 857                 {
 858                         uint32_t _flags_save_string = ndr->flags;
 859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 861                         if (_ptr_comment) {
 862                                 NDR_PULL_ALLOC(ndr, r->comment);
 863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 864                         } else {
 865                                 r->comment = NULL;
 866                         }
 867                         ndr->flags = _flags_save_string;
 868                 }
 869         }
 870         if (ndr_flags & NDR_BUFFERS) {
 871                 {
 872                         uint32_t _flags_save_string = ndr->flags;
 873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 874                         if (r->description) {
 875                                 uint32_t _relative_save_offset;
 876                                 _relative_save_offset = ndr->offset;
 877                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 878                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 879                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 880                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 881                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 882                                 ndr->offset = _relative_save_offset;
 883                         }
 884                         ndr->flags = _flags_save_string;
 885                 }
 886                 {
 887                         uint32_t _flags_save_string = ndr->flags;
 888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 889                         if (r->name) {
 890                                 uint32_t _relative_save_offset;
 891                                 _relative_save_offset = ndr->offset;
 892                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 893                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 894                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 895                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 896                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 897                                 ndr->offset = _relative_save_offset;
 898                         }
 899                         ndr->flags = _flags_save_string;
 900                 }
 901                 {
 902                         uint32_t _flags_save_string = ndr->flags;
 903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 904                         if (r->comment) {
 905                                 uint32_t _relative_save_offset;
 906                                 _relative_save_offset = ndr->offset;
 907                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 908                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 909                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 910                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 911                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 912                                 ndr->offset = _relative_save_offset;
 913                         }
 914                         ndr->flags = _flags_save_string;
 915                 }
 916         }
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 921 {
 922         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 923         ndr->depth++;
 924         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 925         ndr_print_ptr(ndr, "description", r->description);
 926         ndr->depth++;
 927         if (r->description) {
 928                 ndr_print_string(ndr, "description", r->description);
 929         }
 930         ndr->depth--;
 931         ndr_print_ptr(ndr, "name", r->name);
 932         ndr->depth++;
 933         if (r->name) {
 934                 ndr_print_string(ndr, "name", r->name);
 935         }
 936         ndr->depth--;
 937         ndr_print_ptr(ndr, "comment", r->comment);
 938         ndr->depth++;
 939         if (r->comment) {
 940                 ndr_print_string(ndr, "comment", r->comment);
 941         }
 942         ndr->depth--;
 943         ndr->depth--;
 944 }
 945
 946 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
 947 {
 948         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
 949 }
 950
 951 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 952 {
 953         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 958 {
 959         uint32_t v;
 960         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 961         *r = v;
 962         return NDR_ERR_SUCCESS;
 963 }
 964
 965 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 966 {
 967         ndr_print_uint32(ndr, name, r);
 968         ndr->depth++;
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 985         ndr->depth--;
 986 }
 987
 988 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 989 {
 990         if (ndr_flags & NDR_SCALARS) {
 991                 NDR_CHECK(ndr_push_align(ndr, 4));
 992                 {
 993                         uint32_t _flags_save_string = ndr->flags;
 994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 996                         ndr->flags = _flags_save_string;
 997                 }
 998                 {
 999                         uint32_t _flags_save_string = ndr->flags;
1000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1002                         ndr->flags = _flags_save_string;
1003                 }
1004                 {
1005                         uint32_t _flags_save_string = ndr->flags;
1006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1008                         ndr->flags = _flags_save_string;
1009                 }
1010                 {
1011                         uint32_t _flags_save_string = ndr->flags;
1012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1014                         ndr->flags = _flags_save_string;
1015                 }
1016                 {
1017                         uint32_t _flags_save_string = ndr->flags;
1018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1020                         ndr->flags = _flags_save_string;
1021                 }
1022                 {
1023                         uint32_t _flags_save_string = ndr->flags;
1024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1026                         ndr->flags = _flags_save_string;
1027                 }
1028                 {
1029                         uint32_t _flags_save_string = ndr->flags;
1030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1031                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1032                         ndr->flags = _flags_save_string;
1033                 }
1034                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1039                         ndr->flags = _flags_save_string;
1040                 }
1041                 {
1042                         uint32_t _flags_save_string = ndr->flags;
1043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1045                         ndr->flags = _flags_save_string;
1046                 }
1047                 {
1048                         uint32_t _flags_save_string = ndr->flags;
1049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1057                         ndr->flags = _flags_save_string;
1058                 }
1059                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1060                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1065                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1068         }
1069         if (ndr_flags & NDR_BUFFERS) {
1070                 {
1071                         uint32_t _flags_save_string = ndr->flags;
1072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1073                         if (r->servername) {
1074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1076                         }
1077                         ndr->flags = _flags_save_string;
1078                 }
1079                 {
1080                         uint32_t _flags_save_string = ndr->flags;
1081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1082                         if (r->printername) {
1083                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1085                         }
1086                         ndr->flags = _flags_save_string;
1087                 }
1088                 {
1089                         uint32_t _flags_save_string = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1091                         if (r->sharename) {
1092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1094                         }
1095                         ndr->flags = _flags_save_string;
1096                 }
1097                 {
1098                         uint32_t _flags_save_string = ndr->flags;
1099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1100                         if (r->portname) {
1101                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1103                         }
1104                         ndr->flags = _flags_save_string;
1105                 }
1106                 {
1107                         uint32_t _flags_save_string = ndr->flags;
1108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1109                         if (r->drivername) {
1110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1112                         }
1113                         ndr->flags = _flags_save_string;
1114                 }
1115                 {
1116                         uint32_t _flags_save_string = ndr->flags;
1117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1118                         if (r->comment) {
1119                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1120                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1121                         }
1122                         ndr->flags = _flags_save_string;
1123                 }
1124                 {
1125                         uint32_t _flags_save_string = ndr->flags;
1126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1127                         if (r->location) {
1128                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1129                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1130                         }
1131                         ndr->flags = _flags_save_string;
1132                 }
1133                 if (r->devmode) {
1134                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1135                         {
1136                                 struct ndr_push *_ndr_devmode;
1137                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1138                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1139                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1140                         }
1141                 }
1142                 {
1143                         uint32_t _flags_save_string = ndr->flags;
1144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1145                         if (r->sepfile) {
1146                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1147                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1148                         }
1149                         ndr->flags = _flags_save_string;
1150                 }
1151                 {
1152                         uint32_t _flags_save_string = ndr->flags;
1153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1154                         if (r->printprocessor) {
1155                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1156                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1157                         }
1158                         ndr->flags = _flags_save_string;
1159                 }
1160                 {
1161                         uint32_t _flags_save_string = ndr->flags;
1162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1163                         if (r->datatype) {
1164                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1165                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1166                         }
1167                         ndr->flags = _flags_save_string;
1168                 }
1169                 {
1170                         uint32_t _flags_save_string = ndr->flags;
1171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1172                         if (r->parameters) {
1173                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1174                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1175                         }
1176                         ndr->flags = _flags_save_string;
1177                 }
1178                 if (r->secdesc) {
1179                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1180                         {
1181                                 struct ndr_push *_ndr_secdesc;
1182                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1183                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1184                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1185                         }
1186                 }
1187         }
1188         return NDR_ERR_SUCCESS;
1189 }
1190
1191 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1192 {
1193         uint32_t _ptr_servername;
1194         TALLOC_CTX *_mem_save_servername_0;
1195         uint32_t _ptr_printername;
1196         TALLOC_CTX *_mem_save_printername_0;
1197         uint32_t _ptr_sharename;
1198         TALLOC_CTX *_mem_save_sharename_0;
1199         uint32_t _ptr_portname;
1200         TALLOC_CTX *_mem_save_portname_0;
1201         uint32_t _ptr_drivername;
1202         TALLOC_CTX *_mem_save_drivername_0;
1203         uint32_t _ptr_comment;
1204         TALLOC_CTX *_mem_save_comment_0;
1205         uint32_t _ptr_location;
1206         TALLOC_CTX *_mem_save_location_0;
1207         uint32_t _ptr_devmode;
1208         TALLOC_CTX *_mem_save_devmode_0;
1209         uint32_t _ptr_sepfile;
1210         TALLOC_CTX *_mem_save_sepfile_0;
1211         uint32_t _ptr_printprocessor;
1212         TALLOC_CTX *_mem_save_printprocessor_0;
1213         uint32_t _ptr_datatype;
1214         TALLOC_CTX *_mem_save_datatype_0;
1215         uint32_t _ptr_parameters;
1216         TALLOC_CTX *_mem_save_parameters_0;
1217         uint32_t _ptr_secdesc;
1218         TALLOC_CTX *_mem_save_secdesc_0;
1219         if (ndr_flags & NDR_SCALARS) {
1220                 NDR_CHECK(ndr_pull_align(ndr, 4));
1221                 {
1222                         uint32_t _flags_save_string = ndr->flags;
1223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1225                         if (_ptr_servername) {
1226                                 NDR_PULL_ALLOC(ndr, r->servername);
1227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1228                         } else {
1229                                 r->servername = NULL;
1230                         }
1231                         ndr->flags = _flags_save_string;
1232                 }
1233                 {
1234                         uint32_t _flags_save_string = ndr->flags;
1235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1237                         if (_ptr_printername) {
1238                                 NDR_PULL_ALLOC(ndr, r->printername);
1239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1240                         } else {
1241                                 r->printername = NULL;
1242                         }
1243                         ndr->flags = _flags_save_string;
1244                 }
1245                 {
1246                         uint32_t _flags_save_string = ndr->flags;
1247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1248                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1249                         if (_ptr_sharename) {
1250                                 NDR_PULL_ALLOC(ndr, r->sharename);
1251                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1252                         } else {
1253                                 r->sharename = NULL;
1254                         }
1255                         ndr->flags = _flags_save_string;
1256                 }
1257                 {
1258                         uint32_t _flags_save_string = ndr->flags;
1259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1260                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1261                         if (_ptr_portname) {
1262                                 NDR_PULL_ALLOC(ndr, r->portname);
1263                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1264                         } else {
1265                                 r->portname = NULL;
1266                         }
1267                         ndr->flags = _flags_save_string;
1268                 }
1269                 {
1270                         uint32_t _flags_save_string = ndr->flags;
1271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1273                         if (_ptr_drivername) {
1274                                 NDR_PULL_ALLOC(ndr, r->drivername);
1275                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1276                         } else {
1277                                 r->drivername = NULL;
1278                         }
1279                         ndr->flags = _flags_save_string;
1280                 }
1281                 {
1282                         uint32_t _flags_save_string = ndr->flags;
1283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1284                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1285                         if (_ptr_comment) {
1286                                 NDR_PULL_ALLOC(ndr, r->comment);
1287                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1288                         } else {
1289                                 r->comment = NULL;
1290                         }
1291                         ndr->flags = _flags_save_string;
1292                 }
1293                 {
1294                         uint32_t _flags_save_string = ndr->flags;
1295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1296                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1297                         if (_ptr_location) {
1298                                 NDR_PULL_ALLOC(ndr, r->location);
1299                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1300                         } else {
1301                                 r->location = NULL;
1302                         }
1303                         ndr->flags = _flags_save_string;
1304                 }
1305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1306                 if (_ptr_devmode) {
1307                         NDR_PULL_ALLOC(ndr, r->devmode);
1308                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1309                 } else {
1310                         r->devmode = NULL;
1311                 }
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1316                         if (_ptr_sepfile) {
1317                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1319                         } else {
1320                                 r->sepfile = NULL;
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324                 {
1325                         uint32_t _flags_save_string = ndr->flags;
1326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1327                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1328                         if (_ptr_printprocessor) {
1329                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1330                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1331                         } else {
1332                                 r->printprocessor = NULL;
1333                         }
1334                         ndr->flags = _flags_save_string;
1335                 }
1336                 {
1337                         uint32_t _flags_save_string = ndr->flags;
1338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1339                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1340                         if (_ptr_datatype) {
1341                                 NDR_PULL_ALLOC(ndr, r->datatype);
1342                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1343                         } else {
1344                                 r->datatype = NULL;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1352                         if (_ptr_parameters) {
1353                                 NDR_PULL_ALLOC(ndr, r->parameters);
1354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1355                         } else {
1356                                 r->parameters = NULL;
1357                         }
1358                         ndr->flags = _flags_save_string;
1359                 }
1360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1361                 if (_ptr_secdesc) {
1362                         NDR_PULL_ALLOC(ndr, r->secdesc);
1363                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1364                 } else {
1365                         r->secdesc = NULL;
1366                 }
1367                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1369                 if (r->priority > 99) {
1370                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
1371                 }
1372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
1373                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
1374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
1375                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
1376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
1377                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
1378         }
1379         if (ndr_flags & NDR_BUFFERS) {
1380                 {
1381                         uint32_t _flags_save_string = ndr->flags;
1382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1383                         if (r->servername) {
1384                                 uint32_t _relative_save_offset;
1385                                 _relative_save_offset = ndr->offset;
1386                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1387                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1388                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1389                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1390                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1391                                 ndr->offset = _relative_save_offset;
1392                         }
1393                         ndr->flags = _flags_save_string;
1394                 }
1395                 {
1396                         uint32_t _flags_save_string = ndr->flags;
1397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1398                         if (r->printername) {
1399                                 uint32_t _relative_save_offset;
1400                                 _relative_save_offset = ndr->offset;
1401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1402                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1403                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1404                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1406                                 ndr->offset = _relative_save_offset;
1407                         }
1408                         ndr->flags = _flags_save_string;
1409                 }
1410                 {
1411                         uint32_t _flags_save_string = ndr->flags;
1412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1413                         if (r->sharename) {
1414                                 uint32_t _relative_save_offset;
1415                                 _relative_save_offset = ndr->offset;
1416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sharename));
1417                                 _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
1418                                 NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
1419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sharename));
1420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
1421                                 ndr->offset = _relative_save_offset;
1422                         }
1423                         ndr->flags = _flags_save_string;
1424                 }
1425                 {
1426                         uint32_t _flags_save_string = ndr->flags;
1427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1428                         if (r->portname) {
1429                                 uint32_t _relative_save_offset;
1430                                 _relative_save_offset = ndr->offset;
1431                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1432                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1433                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1434                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1435                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1436                                 ndr->offset = _relative_save_offset;
1437                         }
1438                         ndr->flags = _flags_save_string;
1439                 }
1440                 {
1441                         uint32_t _flags_save_string = ndr->flags;
1442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1443                         if (r->drivername) {
1444                                 uint32_t _relative_save_offset;
1445                                 _relative_save_offset = ndr->offset;
1446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->drivername));
1447                                 _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1448                                 NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
1449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->drivername));
1450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
1451                                 ndr->offset = _relative_save_offset;
1452                         }
1453                         ndr->flags = _flags_save_string;
1454                 }
1455                 {
1456                         uint32_t _flags_save_string = ndr->flags;
1457                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1458                         if (r->comment) {
1459                                 uint32_t _relative_save_offset;
1460                                 _relative_save_offset = ndr->offset;
1461                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
1462                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
1463                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
1464                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
1465                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
1466                                 ndr->offset = _relative_save_offset;
1467                         }
1468                         ndr->flags = _flags_save_string;
1469                 }
1470                 {
1471                         uint32_t _flags_save_string = ndr->flags;
1472                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1473                         if (r->location) {
1474                                 uint32_t _relative_save_offset;
1475                                 _relative_save_offset = ndr->offset;
1476                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->location));
1477                                 _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
1478                                 NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
1479                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->location));
1480                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
1481                                 ndr->offset = _relative_save_offset;
1482                         }
1483                         ndr->flags = _flags_save_string;
1484                 }
1485                 if (r->devmode) {
1486                         uint32_t _relative_save_offset;
1487                         _relative_save_offset = ndr->offset;
1488                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
1489                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
1490                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
1491                         {
1492                                 struct ndr_pull *_ndr_devmode;
1493                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1494                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1495                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
1496                         }
1497                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
1498                         ndr->offset = _relative_save_offset;
1499                 }
1500                 {
1501                         uint32_t _flags_save_string = ndr->flags;
1502                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1503                         if (r->sepfile) {
1504                                 uint32_t _relative_save_offset;
1505                                 _relative_save_offset = ndr->offset;
1506                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->sepfile));
1507                                 _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
1508                                 NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
1509                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->sepfile));
1510                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
1511                                 ndr->offset = _relative_save_offset;
1512                         }
1513                         ndr->flags = _flags_save_string;
1514                 }
1515                 {
1516                         uint32_t _flags_save_string = ndr->flags;
1517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1518                         if (r->printprocessor) {
1519                                 uint32_t _relative_save_offset;
1520                                 _relative_save_offset = ndr->offset;
1521                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printprocessor));
1522                                 _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
1523                                 NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
1524                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printprocessor));
1525                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
1526                                 ndr->offset = _relative_save_offset;
1527                         }
1528                         ndr->flags = _flags_save_string;
1529                 }
1530                 {
1531                         uint32_t _flags_save_string = ndr->flags;
1532                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1533                         if (r->datatype) {
1534                                 uint32_t _relative_save_offset;
1535                                 _relative_save_offset = ndr->offset;
1536                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->datatype));
1537                                 _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
1538                                 NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
1539                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->datatype));
1540                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
1541                                 ndr->offset = _relative_save_offset;
1542                         }
1543                         ndr->flags = _flags_save_string;
1544                 }
1545                 {
1546                         uint32_t _flags_save_string = ndr->flags;
1547                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1548                         if (r->parameters) {
1549                                 uint32_t _relative_save_offset;
1550                                 _relative_save_offset = ndr->offset;
1551                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
1552                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
1553                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
1554                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
1555                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
1556                                 ndr->offset = _relative_save_offset;
1557                         }
1558                         ndr->flags = _flags_save_string;
1559                 }
1560                 if (r->secdesc) {
1561                         uint32_t _relative_save_offset;
1562                         _relative_save_offset = ndr->offset;
1563                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1564                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1565                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1566                         {
1567                                 struct ndr_pull *_ndr_secdesc;
1568                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1569                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1570                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1571                         }
1572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1573                         ndr->offset = _relative_save_offset;
1574                 }
1575         }
1576         return NDR_ERR_SUCCESS;
1577 }
1578
1579 _PUBLIC_ void ndr_print_spoolss_PrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo2 *r)
1580 {
1581         ndr_print_struct(ndr, name, "spoolss_PrinterInfo2");
1582         ndr->depth++;
1583         ndr_print_ptr(ndr, "servername", r->servername);
1584         ndr->depth++;
1585         if (r->servername) {
1586                 ndr_print_string(ndr, "servername", r->servername);
1587         }
1588         ndr->depth--;
1589         ndr_print_ptr(ndr, "printername", r->printername);
1590         ndr->depth++;
1591         if (r->printername) {
1592                 ndr_print_string(ndr, "printername", r->printername);
1593         }
1594         ndr->depth--;
1595         ndr_print_ptr(ndr, "sharename", r->sharename);
1596         ndr->depth++;
1597         if (r->sharename) {
1598                 ndr_print_string(ndr, "sharename", r->sharename);
1599         }
1600         ndr->depth--;
1601         ndr_print_ptr(ndr, "portname", r->portname);
1602         ndr->depth++;
1603         if (r->portname) {
1604                 ndr_print_string(ndr, "portname", r->portname);
1605         }
1606         ndr->depth--;
1607         ndr_print_ptr(ndr, "drivername", r->drivername);
1608         ndr->depth++;
1609         if (r->drivername) {
1610                 ndr_print_string(ndr, "drivername", r->drivername);
1611         }
1612         ndr->depth--;
1613         ndr_print_ptr(ndr, "comment", r->comment);
1614         ndr->depth++;
1615         if (r->comment) {
1616                 ndr_print_string(ndr, "comment", r->comment);
1617         }
1618         ndr->depth--;
1619         ndr_print_ptr(ndr, "location", r->location);
1620         ndr->depth++;
1621         if (r->location) {
1622                 ndr_print_string(ndr, "location", r->location);
1623         }
1624         ndr->depth--;
1625         ndr_print_ptr(ndr, "devmode", r->devmode);
1626         ndr->depth++;
1627         if (r->devmode) {
1628                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
1629         }
1630         ndr->depth--;
1631         ndr_print_ptr(ndr, "sepfile", r->sepfile);
1632         ndr->depth++;
1633         if (r->sepfile) {
1634                 ndr_print_string(ndr, "sepfile", r->sepfile);
1635         }
1636         ndr->depth--;
1637         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
1638         ndr->depth++;
1639         if (r->printprocessor) {
1640                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
1641         }
1642         ndr->depth--;
1643         ndr_print_ptr(ndr, "datatype", r->datatype);
1644         ndr->depth++;
1645         if (r->datatype) {
1646                 ndr_print_string(ndr, "datatype", r->datatype);
1647         }
1648         ndr->depth--;
1649         ndr_print_ptr(ndr, "parameters", r->parameters);
1650         ndr->depth++;
1651         if (r->parameters) {
1652                 ndr_print_string(ndr, "parameters", r->parameters);
1653         }
1654         ndr->depth--;
1655         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1656         ndr->depth++;
1657         if (r->secdesc) {
1658                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1659         }
1660         ndr->depth--;
1661         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1662         ndr_print_uint32(ndr, "priority", r->priority);
1663         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
1664         ndr_print_uint32(ndr, "starttime", r->starttime);
1665         ndr_print_uint32(ndr, "untiltime", r->untiltime);
1666         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
1667         ndr_print_uint32(ndr, "cjobs", r->cjobs);
1668         ndr_print_uint32(ndr, "averageppm", r->averageppm);
1669         ndr->depth--;
1670 }
1671
1672 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo2(const struct spoolss_PrinterInfo2 *r, struct smb_iconv_convenience *ic, int flags)
1673 {
1674         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo2, ic);
1675 }
1676
1677 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo3 *r)
1678 {
1679         if (ndr_flags & NDR_SCALARS) {
1680                 NDR_CHECK(ndr_push_align(ndr, 4));
1681                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1682         }
1683         if (ndr_flags & NDR_BUFFERS) {
1684                 if (r->secdesc) {
1685                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1686                         {
1687                                 struct ndr_push *_ndr_secdesc;
1688                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1689                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1690                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1691                         }
1692                 }
1693         }
1694         return NDR_ERR_SUCCESS;
1695 }
1696
1697 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo3 *r)
1698 {
1699         uint32_t _ptr_secdesc;
1700         TALLOC_CTX *_mem_save_secdesc_0;
1701         if (ndr_flags & NDR_SCALARS) {
1702                 NDR_CHECK(ndr_pull_align(ndr, 4));
1703                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1704                 if (_ptr_secdesc) {
1705                         NDR_PULL_ALLOC(ndr, r->secdesc);
1706                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1707                 } else {
1708                         r->secdesc = NULL;
1709                 }
1710         }
1711         if (ndr_flags & NDR_BUFFERS) {
1712                 if (r->secdesc) {
1713                         uint32_t _relative_save_offset;
1714                         _relative_save_offset = ndr->offset;
1715                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
1716                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
1717                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
1718                         {
1719                                 struct ndr_pull *_ndr_secdesc;
1720                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1721                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1722                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1723                         }
1724                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
1725                         ndr->offset = _relative_save_offset;
1726                 }
1727         }
1728         return NDR_ERR_SUCCESS;
1729 }
1730
1731 _PUBLIC_ void ndr_print_spoolss_PrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo3 *r)
1732 {
1733         ndr_print_struct(ndr, name, "spoolss_PrinterInfo3");
1734         ndr->depth++;
1735         ndr_print_ptr(ndr, "secdesc", r->secdesc);
1736         ndr->depth++;
1737         if (r->secdesc) {
1738                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
1739         }
1740         ndr->depth--;
1741         ndr->depth--;
1742 }
1743
1744 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo3(const struct spoolss_PrinterInfo3 *r, struct smb_iconv_convenience *ic, int flags)
1745 {
1746         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo3, ic);
1747 }
1748
1749 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo4 *r)
1750 {
1751         if (ndr_flags & NDR_SCALARS) {
1752                 NDR_CHECK(ndr_push_align(ndr, 4));
1753                 {
1754                         uint32_t _flags_save_string = ndr->flags;
1755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1756                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1757                         ndr->flags = _flags_save_string;
1758                 }
1759                 {
1760                         uint32_t _flags_save_string = ndr->flags;
1761                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1762                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
1763                         ndr->flags = _flags_save_string;
1764                 }
1765                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1766         }
1767         if (ndr_flags & NDR_BUFFERS) {
1768                 {
1769                         uint32_t _flags_save_string = ndr->flags;
1770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1771                         if (r->printername) {
1772                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1773                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1774                         }
1775                         ndr->flags = _flags_save_string;
1776                 }
1777                 {
1778                         uint32_t _flags_save_string = ndr->flags;
1779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1780                         if (r->servername) {
1781                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1783                         }
1784                         ndr->flags = _flags_save_string;
1785                 }
1786         }
1787         return NDR_ERR_SUCCESS;
1788 }
1789
1790 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo4 *r)
1791 {
1792         uint32_t _ptr_printername;
1793         TALLOC_CTX *_mem_save_printername_0;
1794         uint32_t _ptr_servername;
1795         TALLOC_CTX *_mem_save_servername_0;
1796         if (ndr_flags & NDR_SCALARS) {
1797                 NDR_CHECK(ndr_pull_align(ndr, 4));
1798                 {
1799                         uint32_t _flags_save_string = ndr->flags;
1800                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1801                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1802                         if (_ptr_printername) {
1803                                 NDR_PULL_ALLOC(ndr, r->printername);
1804                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1805                         } else {
1806                                 r->printername = NULL;
1807                         }
1808                         ndr->flags = _flags_save_string;
1809                 }
1810                 {
1811                         uint32_t _flags_save_string = ndr->flags;
1812                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1813                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1814                         if (_ptr_servername) {
1815                                 NDR_PULL_ALLOC(ndr, r->servername);
1816                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1817                         } else {
1818                                 r->servername = NULL;
1819                         }
1820                         ndr->flags = _flags_save_string;
1821                 }
1822                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1823         }
1824         if (ndr_flags & NDR_BUFFERS) {
1825                 {
1826                         uint32_t _flags_save_string = ndr->flags;
1827                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1828                         if (r->printername) {
1829                                 uint32_t _relative_save_offset;
1830                                 _relative_save_offset = ndr->offset;
1831                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1832                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1833                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1834                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1835                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1836                                 ndr->offset = _relative_save_offset;
1837                         }
1838                         ndr->flags = _flags_save_string;
1839                 }
1840                 {
1841                         uint32_t _flags_save_string = ndr->flags;
1842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1843                         if (r->servername) {
1844                                 uint32_t _relative_save_offset;
1845                                 _relative_save_offset = ndr->offset;
1846                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
1847                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1848                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
1849                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
1850                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
1851                                 ndr->offset = _relative_save_offset;
1852                         }
1853                         ndr->flags = _flags_save_string;
1854                 }
1855         }
1856         return NDR_ERR_SUCCESS;
1857 }
1858
1859 _PUBLIC_ void ndr_print_spoolss_PrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo4 *r)
1860 {
1861         ndr_print_struct(ndr, name, "spoolss_PrinterInfo4");
1862         ndr->depth++;
1863         ndr_print_ptr(ndr, "printername", r->printername);
1864         ndr->depth++;
1865         if (r->printername) {
1866                 ndr_print_string(ndr, "printername", r->printername);
1867         }
1868         ndr->depth--;
1869         ndr_print_ptr(ndr, "servername", r->servername);
1870         ndr->depth++;
1871         if (r->servername) {
1872                 ndr_print_string(ndr, "servername", r->servername);
1873         }
1874         ndr->depth--;
1875         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
1876         ndr->depth--;
1877 }
1878
1879 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo4(const struct spoolss_PrinterInfo4 *r, struct smb_iconv_convenience *ic, int flags)
1880 {
1881         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo4, ic);
1882 }
1883
1884 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo5 *r)
1885 {
1886         if (ndr_flags & NDR_SCALARS) {
1887                 NDR_CHECK(ndr_push_align(ndr, 4));
1888                 {
1889                         uint32_t _flags_save_string = ndr->flags;
1890                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1891                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1892                         ndr->flags = _flags_save_string;
1893                 }
1894                 {
1895                         uint32_t _flags_save_string = ndr->flags;
1896                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1897                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1898                         ndr->flags = _flags_save_string;
1899                 }
1900                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1901                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
1902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
1903         }
1904         if (ndr_flags & NDR_BUFFERS) {
1905                 {
1906                         uint32_t _flags_save_string = ndr->flags;
1907                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1908                         if (r->printername) {
1909                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1910                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1911                         }
1912                         ndr->flags = _flags_save_string;
1913                 }
1914                 {
1915                         uint32_t _flags_save_string = ndr->flags;
1916                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1917                         if (r->portname) {
1918                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1919                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1920                         }
1921                         ndr->flags = _flags_save_string;
1922                 }
1923         }
1924         return NDR_ERR_SUCCESS;
1925 }
1926
1927 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo5 *r)
1928 {
1929         uint32_t _ptr_printername;
1930         TALLOC_CTX *_mem_save_printername_0;
1931         uint32_t _ptr_portname;
1932         TALLOC_CTX *_mem_save_portname_0;
1933         if (ndr_flags & NDR_SCALARS) {
1934                 NDR_CHECK(ndr_pull_align(ndr, 4));
1935                 {
1936                         uint32_t _flags_save_string = ndr->flags;
1937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1938                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1939                         if (_ptr_printername) {
1940                                 NDR_PULL_ALLOC(ndr, r->printername);
1941                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1942                         } else {
1943                                 r->printername = NULL;
1944                         }
1945                         ndr->flags = _flags_save_string;
1946                 }
1947                 {
1948                         uint32_t _flags_save_string = ndr->flags;
1949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1950                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1951                         if (_ptr_portname) {
1952                                 NDR_PULL_ALLOC(ndr, r->portname);
1953                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1954                         } else {
1955                                 r->portname = NULL;
1956                         }
1957                         ndr->flags = _flags_save_string;
1958                 }
1959                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1960                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
1961                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
1962         }
1963         if (ndr_flags & NDR_BUFFERS) {
1964                 {
1965                         uint32_t _flags_save_string = ndr->flags;
1966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1967                         if (r->printername) {
1968                                 uint32_t _relative_save_offset;
1969                                 _relative_save_offset = ndr->offset;
1970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
1971                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
1972                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
1973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
1974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
1975                                 ndr->offset = _relative_save_offset;
1976                         }
1977                         ndr->flags = _flags_save_string;
1978                 }
1979                 {
1980                         uint32_t _flags_save_string = ndr->flags;
1981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1982                         if (r->portname) {
1983                                 uint32_t _relative_save_offset;
1984                                 _relative_save_offset = ndr->offset;
1985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->portname));
1986                                 _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
1987                                 NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
1988                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->portname));
1989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
1990                                 ndr->offset = _relative_save_offset;
1991                         }
1992                         ndr->flags = _flags_save_string;
1993                 }
1994         }
1995         return NDR_ERR_SUCCESS;
1996 }
1997
1998 _PUBLIC_ void ndr_print_spoolss_PrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo5 *r)
1999 {
2000         ndr_print_struct(ndr, name, "spoolss_PrinterInfo5");
2001         ndr->depth++;
2002         ndr_print_ptr(ndr, "printername", r->printername);
2003         ndr->depth++;
2004         if (r->printername) {
2005                 ndr_print_string(ndr, "printername", r->printername);
2006         }
2007         ndr->depth--;
2008         ndr_print_ptr(ndr, "portname", r->portname);
2009         ndr->depth++;
2010         if (r->portname) {
2011                 ndr_print_string(ndr, "portname", r->portname);
2012         }
2013         ndr->depth--;
2014         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
2015         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
2016         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
2017         ndr->depth--;
2018 }
2019
2020 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo5(const struct spoolss_PrinterInfo5 *r, struct smb_iconv_convenience *ic, int flags)
2021 {
2022         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo5, ic);
2023 }
2024
2025 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo6 *r)
2026 {
2027         if (ndr_flags & NDR_SCALARS) {
2028                 NDR_CHECK(ndr_push_align(ndr, 4));
2029                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
2030         }
2031         if (ndr_flags & NDR_BUFFERS) {
2032         }
2033         return NDR_ERR_SUCCESS;
2034 }
2035
2036 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo6 *r)
2037 {
2038         if (ndr_flags & NDR_SCALARS) {
2039                 NDR_CHECK(ndr_pull_align(ndr, 4));
2040                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
2041         }
2042         if (ndr_flags & NDR_BUFFERS) {
2043         }
2044         return NDR_ERR_SUCCESS;
2045 }
2046
2047 _PUBLIC_ void ndr_print_spoolss_PrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo6 *r)
2048 {
2049         ndr_print_struct(ndr, name, "spoolss_PrinterInfo6");
2050         ndr->depth++;
2051         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
2052         ndr->depth--;
2053 }
2054
2055 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo6(const struct spoolss_PrinterInfo6 *r, struct smb_iconv_convenience *ic, int flags)
2056 {
2057         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo6, ic);
2058 }
2059
2060 static enum ndr_err_code ndr_push_spoolss_DsPrintAction(struct ndr_push *ndr, int ndr_flags, uint32_t r)
2061 {
2062         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
2063         return NDR_ERR_SUCCESS;
2064 }
2065
2066 static enum ndr_err_code ndr_pull_spoolss_DsPrintAction(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
2067 {
2068         uint32_t v;
2069         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
2070         *r = v;
2071         return NDR_ERR_SUCCESS;
2072 }
2073
2074 _PUBLIC_ void ndr_print_spoolss_DsPrintAction(struct ndr_print *ndr, const char *name, uint32_t r)
2075 {
2076         ndr_print_uint32(ndr, name, r);
2077         ndr->depth++;
2078         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PUBLISH", DSPRINT_PUBLISH, r);
2079         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UPDATE", DSPRINT_UPDATE, r);
2080         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_UNPUBLISH", DSPRINT_UNPUBLISH, r);
2081         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_REPUBLISH", DSPRINT_REPUBLISH, r);
2082         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DSPRINT_PENDING", DSPRINT_PENDING, r);
2083         ndr->depth--;
2084 }
2085
2086 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo7 *r)
2087 {
2088         if (ndr_flags & NDR_SCALARS) {
2089                 NDR_CHECK(ndr_push_align(ndr, 4));
2090                 {
2091                         uint32_t _flags_save_string = ndr->flags;
2092                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2093                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->guid));
2094                         ndr->flags = _flags_save_string;
2095                 }
2096                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
2097         }
2098         if (ndr_flags & NDR_BUFFERS) {
2099                 {
2100                         uint32_t _flags_save_string = ndr->flags;
2101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2102                         if (r->guid) {
2103                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->guid));
2104                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->guid));
2105                         }
2106                         ndr->flags = _flags_save_string;
2107                 }
2108         }
2109         return NDR_ERR_SUCCESS;
2110 }
2111
2112 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo7 *r)
2113 {
2114         uint32_t _ptr_guid;
2115         TALLOC_CTX *_mem_save_guid_0;
2116         if (ndr_flags & NDR_SCALARS) {
2117                 NDR_CHECK(ndr_pull_align(ndr, 4));
2118                 {
2119                         uint32_t _flags_save_string = ndr->flags;
2120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2121                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
2122                         if (_ptr_guid) {
2123                                 NDR_PULL_ALLOC(ndr, r->guid);
2124                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->guid, _ptr_guid));
2125                         } else {
2126                                 r->guid = NULL;
2127                         }
2128                         ndr->flags = _flags_save_string;
2129                 }
2130                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
2131         }
2132         if (ndr_flags & NDR_BUFFERS) {
2133                 {
2134                         uint32_t _flags_save_string = ndr->flags;
2135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2136                         if (r->guid) {
2137                                 uint32_t _relative_save_offset;
2138                                 _relative_save_offset = ndr->offset;
2139                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->guid));
2140                                 _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
2141                                 NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
2142                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->guid));
2143                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
2144                                 ndr->offset = _relative_save_offset;
2145                         }
2146                         ndr->flags = _flags_save_string;
2147                 }
2148         }
2149         return NDR_ERR_SUCCESS;
2150 }
2151
2152 _PUBLIC_ void ndr_print_spoolss_PrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo7 *r)
2153 {
2154         ndr_print_struct(ndr, name, "spoolss_PrinterInfo7");
2155         ndr->depth++;
2156         ndr_print_ptr(ndr, "guid", r->guid);
2157         ndr->depth++;
2158         if (r->guid) {
2159                 ndr_print_string(ndr, "guid", r->guid);
2160         }
2161         ndr->depth--;
2162         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
2163         ndr->depth--;
2164 }
2165
2166 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo7(const struct spoolss_PrinterInfo7 *r, struct smb_iconv_convenience *ic, int flags)
2167 {
2168         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo7, ic);
2169 }
2170
2171 static enum ndr_err_code ndr_push_spoolss_DeviceModeInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceModeInfo *r)
2172 {
2173         if (ndr_flags & NDR_SCALARS) {
2174                 NDR_CHECK(ndr_push_align(ndr, 4));
2175                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
2176         }
2177         if (ndr_flags & NDR_BUFFERS) {
2178                 if (r->devmode) {
2179                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
2180                         {
2181                                 struct ndr_push *_ndr_devmode;
2182                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2183                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2184                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
2185                         }
2186                 }
2187         }
2188         return NDR_ERR_SUCCESS;
2189 }
2190
2191 static enum ndr_err_code ndr_pull_spoolss_DeviceModeInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceModeInfo *r)
2192 {
2193         uint32_t _ptr_devmode;
2194         TALLOC_CTX *_mem_save_devmode_0;
2195         if (ndr_flags & NDR_SCALARS) {
2196                 NDR_CHECK(ndr_pull_align(ndr, 4));
2197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2198                 if (_ptr_devmode) {
2199                         NDR_PULL_ALLOC(ndr, r->devmode);
2200                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
2201                 } else {
2202                         r->devmode = NULL;
2203                 }
2204         }
2205         if (ndr_flags & NDR_BUFFERS) {
2206                 if (r->devmode) {
2207                         uint32_t _relative_save_offset;
2208                         _relative_save_offset = ndr->offset;
2209                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
2210                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2211                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2212                         {
2213                                 struct ndr_pull *_ndr_devmode;
2214                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
2215                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2216                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
2217                         }
2218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2219                         ndr->offset = _relative_save_offset;
2220                 }
2221         }
2222         return NDR_ERR_SUCCESS;
2223 }
2224
2225 _PUBLIC_ void ndr_print_spoolss_DeviceModeInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceModeInfo *r)
2226 {
2227         ndr_print_struct(ndr, name, "spoolss_DeviceModeInfo");
2228         ndr->depth++;
2229         ndr_print_ptr(ndr, "devmode", r->devmode);
2230         ndr->depth++;
2231         if (r->devmode) {
2232                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2233         }
2234         ndr->depth--;
2235         ndr->depth--;
2236 }
2237
2238 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterInfo *r)
2239 {
2240         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
2241         if (ndr_flags & NDR_SCALARS) {
2242                 int level = ndr_push_get_switch_value(ndr, r);
2243                 switch (level) {
2244                         case 0: {
2245                                 NDR_CHECK(ndr_push_align(ndr, 4));
2246                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2247                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2248                         break; }
2249
2250                         case 1: {
2251                                 NDR_CHECK(ndr_push_align(ndr, 4));
2252                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2253                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2254                         break; }
2255
2256                         case 2: {
2257                                 NDR_CHECK(ndr_push_align(ndr, 4));
2258                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2259                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2260                         break; }
2261
2262                         case 3: {
2263                                 NDR_CHECK(ndr_push_align(ndr, 4));
2264                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2265                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2266                         break; }
2267
2268                         case 4: {
2269                                 NDR_CHECK(ndr_push_align(ndr, 4));
2270                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2271                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2272                         break; }
2273
2274                         case 5: {
2275                                 NDR_CHECK(ndr_push_align(ndr, 4));
2276                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2277                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2278                         break; }
2279
2280                         case 6: {
2281                                 NDR_CHECK(ndr_push_align(ndr, 4));
2282                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2283                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2284                         break; }
2285
2286                         case 7: {
2287                                 NDR_CHECK(ndr_push_align(ndr, 4));
2288                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2289                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2290                         break; }
2291
2292                         case 8: {
2293                                 NDR_CHECK(ndr_push_align(ndr, 4));
2294                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2295                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2296                         break; }
2297
2298                         case 9: {
2299                                 NDR_CHECK(ndr_push_align(ndr, 4));
2300                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
2301                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2302                         break; }
2303
2304                         default: {
2305                         break; }
2306
2307                 }
2308         }
2309         if (ndr_flags & NDR_BUFFERS) {
2310                 int level = ndr_push_get_switch_value(ndr, r);
2311                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
2312                 switch (level) {
2313                         case 0:
2314                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2315                         break;
2316
2317                         case 1:
2318                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2319                         break;
2320
2321                         case 2:
2322                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2323                         break;
2324
2325                         case 3:
2326                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2327                         break;
2328
2329                         case 4:
2330                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2331                         break;
2332
2333                         case 5:
2334                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2335                         break;
2336
2337                         case 6:
2338                         break;
2339
2340                         case 7:
2341                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2342                         break;
2343
2344                         case 8:
2345                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2346                         break;
2347
2348                         case 9:
2349                                 NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2350                         break;
2351
2352                         default:
2353                         break;
2354
2355                 }
2356         }
2357         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
2358         return NDR_ERR_SUCCESS;
2359 }
2360
2361 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterInfo *r)
2362 {
2363         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
2364         int level;
2365         level = ndr_pull_get_switch_value(ndr, r);
2366         if (ndr_flags & NDR_SCALARS) {
2367                 switch (level) {
2368                         case 0: {
2369                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2370                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2371                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_SCALARS, &r->info0));
2372                         break; }
2373
2374                         case 1: {
2375                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2376                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2377                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_SCALARS, &r->info1));
2378                         break; }
2379
2380                         case 2: {
2381                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2382                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2383                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_SCALARS, &r->info2));
2384                         break; }
2385
2386                         case 3: {
2387                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2388                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2389                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_SCALARS, &r->info3));
2390                         break; }
2391
2392                         case 4: {
2393                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2394                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2395                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_SCALARS, &r->info4));
2396                         break; }
2397
2398                         case 5: {
2399                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2400                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2401                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_SCALARS, &r->info5));
2402                         break; }
2403
2404                         case 6: {
2405                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2406                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2407                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo6(ndr, NDR_SCALARS, &r->info6));
2408                         break; }
2409
2410                         case 7: {
2411                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2412                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2413                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_SCALARS, &r->info7));
2414                         break; }
2415
2416                         case 8: {
2417                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2418                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2419                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info8));
2420                         break; }
2421
2422                         case 9: {
2423                                 NDR_CHECK(ndr_pull_align(ndr, 4));
2424                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
2425                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS, &r->info9));
2426                         break; }
2427
2428                         default: {
2429                         break; }
2430
2431                 }
2432         }
2433         if (ndr_flags & NDR_BUFFERS) {
2434                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
2435                 switch (level) {
2436                         case 0:
2437                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo0(ndr, NDR_BUFFERS, &r->info0));
2438                         break;
2439
2440                         case 1:
2441                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo1(ndr, NDR_BUFFERS, &r->info1));
2442                         break;
2443
2444                         case 2:
2445                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo2(ndr, NDR_BUFFERS, &r->info2));
2446                         break;
2447
2448                         case 3:
2449                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo3(ndr, NDR_BUFFERS, &r->info3));
2450                         break;
2451
2452                         case 4:
2453                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo4(ndr, NDR_BUFFERS, &r->info4));
2454                         break;
2455
2456                         case 5:
2457                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo5(ndr, NDR_BUFFERS, &r->info5));
2458                         break;
2459
2460                         case 6:
2461                         break;
2462
2463                         case 7:
2464                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo7(ndr, NDR_BUFFERS, &r->info7));
2465                         break;
2466
2467                         case 8:
2468                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info8));
2469                         break;
2470
2471                         case 9:
2472                                 NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_BUFFERS, &r->info9));
2473                         break;
2474
2475                         default:
2476                         break;
2477
2478                 }
2479         }
2480         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
2481         return NDR_ERR_SUCCESS;
2482 }
2483
2484 _PUBLIC_ void ndr_print_spoolss_PrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrinterInfo *r)
2485 {
2486         int level;
2487         level = ndr_print_get_switch_value(ndr, r);
2488         ndr_print_union(ndr, name, level, "spoolss_PrinterInfo");
2489         switch (level) {
2490                 case 0:
2491                         ndr_print_spoolss_PrinterInfo0(ndr, "info0", &r->info0);
2492                 break;
2493
2494                 case 1:
2495                         ndr_print_spoolss_PrinterInfo1(ndr, "info1", &r->info1);
2496                 break;
2497
2498                 case 2:
2499                         ndr_print_spoolss_PrinterInfo2(ndr, "info2", &r->info2);
2500                 break;
2501
2502                 case 3:
2503                         ndr_print_spoolss_PrinterInfo3(ndr, "info3", &r->info3);
2504                 break;
2505
2506                 case 4:
2507                         ndr_print_spoolss_PrinterInfo4(ndr, "info4", &r->info4);
2508                 break;
2509
2510                 case 5:
2511                         ndr_print_spoolss_PrinterInfo5(ndr, "info5", &r->info5);
2512                 break;
2513
2514                 case 6:
2515                         ndr_print_spoolss_PrinterInfo6(ndr, "info6", &r->info6);
2516                 break;
2517
2518                 case 7:
2519                         ndr_print_spoolss_PrinterInfo7(ndr, "info7", &r->info7);
2520                 break;
2521
2522                 case 8:
2523                         ndr_print_spoolss_DeviceModeInfo(ndr, "info8", &r->info8);
2524                 break;
2525
2526                 case 9:
2527                         ndr_print_spoolss_DeviceModeInfo(ndr, "info9", &r->info9);
2528                 break;
2529
2530                 default:
2531                 break;
2532
2533         }
2534 }
2535
2536 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo(const union spoolss_PrinterInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
2537 {
2538         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo, ic);
2539 }
2540
2541 static enum ndr_err_code ndr_push_spoolss_DevmodeContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DevmodeContainer *r)
2542 {
2543         if (ndr_flags & NDR_SCALARS) {
2544                 NDR_CHECK(ndr_push_align(ndr, 4));
2545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2546                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
2547         }
2548         if (ndr_flags & NDR_BUFFERS) {
2549                 if (r->devmode) {
2550                         {
2551                                 struct ndr_push *_ndr_devmode;
2552                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2553                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2554                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 4, _ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags)));
2555                         }
2556                 }
2557         }
2558         return NDR_ERR_SUCCESS;
2559 }
2560
2561 static enum ndr_err_code ndr_pull_spoolss_DevmodeContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DevmodeContainer *r)
2562 {
2563         uint32_t _ptr_devmode;
2564         TALLOC_CTX *_mem_save_devmode_0;
2565         if (ndr_flags & NDR_SCALARS) {
2566                 NDR_CHECK(ndr_pull_align(ndr, 4));
2567                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
2568                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
2569                 if (_ptr_devmode) {
2570                         NDR_PULL_ALLOC(ndr, r->devmode);
2571                 } else {
2572                         r->devmode = NULL;
2573                 }
2574         }
2575         if (ndr_flags & NDR_BUFFERS) {
2576                 if (r->devmode) {
2577                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
2578                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
2579                         {
2580                                 struct ndr_pull *_ndr_devmode;
2581                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 4, r->_ndr_size));
2582                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
2583                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 4, r->_ndr_size));
2584                         }
2585                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
2586                 }
2587         }
2588         return NDR_ERR_SUCCESS;
2589 }
2590
2591 _PUBLIC_ void ndr_print_spoolss_DevmodeContainer(struct ndr_print *ndr, const char *name, const struct spoolss_DevmodeContainer *r)
2592 {
2593         ndr_print_struct(ndr, name, "spoolss_DevmodeContainer");
2594         ndr->depth++;
2595         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?_ndr_size_spoolss_DeviceMode(r->devmode, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
2596         ndr_print_ptr(ndr, "devmode", r->devmode);
2597         ndr->depth++;
2598         if (r->devmode) {
2599                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
2600         }
2601         ndr->depth--;
2602         ndr->depth--;
2603 }
2604
2605 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo1 *r)
2606 {
2607         if (ndr_flags & NDR_SCALARS) {
2608                 NDR_CHECK(ndr_push_align(ndr, 4));
2609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2610                 {
2611                         uint32_t _flags_save_string = ndr->flags;
2612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2613                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2614                         ndr->flags = _flags_save_string;
2615                 }
2616                 {
2617                         uint32_t _flags_save_string = ndr->flags;
2618                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2619                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2620                         ndr->flags = _flags_save_string;
2621                 }
2622                 {
2623                         uint32_t _flags_save_string = ndr->flags;
2624                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2625                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2626                         ndr->flags = _flags_save_string;
2627                 }
2628                 {
2629                         uint32_t _flags_save_string = ndr->flags;
2630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2631                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2632                         ndr->flags = _flags_save_string;
2633                 }
2634                 {
2635                         uint32_t _flags_save_string = ndr->flags;
2636                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2637                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
2638                         ndr->flags = _flags_save_string;
2639                 }
2640                 {
2641                         uint32_t _flags_save_string = ndr->flags;
2642                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2643                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
2644                         ndr->flags = _flags_save_string;
2645                 }
2646                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
2647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
2648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
2649                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
2650                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
2651                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2652         }
2653         if (ndr_flags & NDR_BUFFERS) {
2654                 {
2655                         uint32_t _flags_save_string = ndr->flags;
2656                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2657                         if (r->printer_name) {
2658                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
2659                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
2660                         }
2661                         ndr->flags = _flags_save_string;
2662                 }
2663                 {
2664                         uint32_t _flags_save_string = ndr->flags;
2665                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2666                         if (r->server_name) {
2667                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
2668                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
2669                         }
2670                         ndr->flags = _flags_save_string;
2671                 }
2672                 {
2673                         uint32_t _flags_save_string = ndr->flags;
2674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2675                         if (r->user_name) {
2676                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
2677                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
2678                         }
2679                         ndr->flags = _flags_save_string;
2680                 }
2681                 {
2682                         uint32_t _flags_save_string = ndr->flags;
2683                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2684                         if (r->document_name) {
2685                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
2686                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
2687                         }
2688                         ndr->flags = _flags_save_string;
2689                 }
2690                 {
2691                         uint32_t _flags_save_string = ndr->flags;
2692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2693                         if (r->data_type) {
2694                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
2695                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
2696                         }
2697                         ndr->flags = _flags_save_string;
2698                 }
2699                 {
2700                         uint32_t _flags_save_string = ndr->flags;
2701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2702                         if (r->text_status) {
2703                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
2704                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
2705                         }
2706                         ndr->flags = _flags_save_string;
2707                 }
2708         }
2709         return NDR_ERR_SUCCESS;
2710 }
2711
2712 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo1 *r)
2713 {
2714         uint32_t _ptr_printer_name;
2715         TALLOC_CTX *_mem_save_printer_name_0;
2716         uint32_t _ptr_server_name;
2717         TALLOC_CTX *_mem_save_server_name_0;
2718         uint32_t _ptr_user_name;
2719         TALLOC_CTX *_mem_save_user_name_0;
2720         uint32_t _ptr_document_name;
2721         TALLOC_CTX *_mem_save_document_name_0;
2722         uint32_t _ptr_data_type;
2723         TALLOC_CTX *_mem_save_data_type_0;
2724         uint32_t _ptr_text_status;
2725         TALLOC_CTX *_mem_save_text_status_0;
2726         if (ndr_flags & NDR_SCALARS) {
2727                 NDR_CHECK(ndr_pull_align(ndr, 4));
2728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
2729                 {
2730                         uint32_t _flags_save_string = ndr->flags;
2731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2732                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
2733                         if (_ptr_printer_name) {
2734                                 NDR_PULL_ALLOC(ndr, r->printer_name);
2735                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
2736                         } else {
2737                                 r->printer_name = NULL;
2738                         }
2739                         ndr->flags = _flags_save_string;
2740                 }
2741                 {
2742                         uint32_t _flags_save_string = ndr->flags;
2743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2744                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
2745                         if (_ptr_server_name) {
2746                                 NDR_PULL_ALLOC(ndr, r->server_name);
2747                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
2748                         } else {
2749                                 r->server_name = NULL;
2750                         }
2751                         ndr->flags = _flags_save_string;
2752                 }
2753                 {
2754                         uint32_t _flags_save_string = ndr->flags;
2755                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2756                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
2757                         if (_ptr_user_name) {
2758                                 NDR_PULL_ALLOC(ndr, r->user_name);
2759                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
2760                         } else {
2761                                 r->user_name = NULL;
2762                         }
2763                         ndr->flags = _flags_save_string;
2764                 }
2765                 {
2766                         uint32_t _flags_save_string = ndr->flags;
2767                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2768                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
2769                         if (_ptr_document_name) {
2770                                 NDR_PULL_ALLOC(ndr, r->document_name);
2771                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
2772                         } else {
2773                                 r->document_name = NULL;
2774                         }
2775                         ndr->flags = _flags_save_string;
2776                 }
2777                 {
2778                         uint32_t _flags_save_string = ndr->flags;
2779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2780                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
2781                         if (_ptr_data_type) {
2782                                 NDR_PULL_ALLOC(ndr, r->data_type);
2783                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
2784                         } else {
2785                                 r->data_type = NULL;
2786                         }
2787                         ndr->flags = _flags_save_string;
2788                 }
2789                 {
2790                         uint32_t _flags_save_string = ndr->flags;
2791                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2792                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
2793                         if (_ptr_text_status) {
2794                                 NDR_PULL_ALLOC(ndr, r->text_status);
2795                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
2796                         } else {
2797                                 r->text_status = NULL;
2798                         }
2799                         ndr->flags = _flags_save_string;
2800                 }
2801                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
2802                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
2803                 if (r->priority > 99) {
2804                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
2805                 }
2806                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
2807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
2808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
2809                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
2810         }
2811         if (ndr_flags & NDR_BUFFERS) {
2812                 {
2813                         uint32_t _flags_save_string = ndr->flags;
2814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2815                         if (r->printer_name) {
2816                                 uint32_t _relative_save_offset;
2817                                 _relative_save_offset = ndr->offset;
2818                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
2819                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2820                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
2821                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
2822                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
2823                                 ndr->offset = _relative_save_offset;
2824                         }
2825                         ndr->flags = _flags_save_string;
2826                 }
2827                 {
2828                         uint32_t _flags_save_string = ndr->flags;
2829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2830                         if (r->server_name) {
2831                                 uint32_t _relative_save_offset;
2832                                 _relative_save_offset = ndr->offset;
2833                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
2834                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2835                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
2836                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
2837                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
2838                                 ndr->offset = _relative_save_offset;
2839                         }
2840                         ndr->flags = _flags_save_string;
2841                 }
2842                 {
2843                         uint32_t _flags_save_string = ndr->flags;
2844                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2845                         if (r->user_name) {
2846                                 uint32_t _relative_save_offset;
2847                                 _relative_save_offset = ndr->offset;
2848                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
2849                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2850                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
2851                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
2852                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
2853                                 ndr->offset = _relative_save_offset;
2854                         }
2855                         ndr->flags = _flags_save_string;
2856                 }
2857                 {
2858                         uint32_t _flags_save_string = ndr->flags;
2859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2860                         if (r->document_name) {
2861                                 uint32_t _relative_save_offset;
2862                                 _relative_save_offset = ndr->offset;
2863                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
2864                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
2865                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
2866                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
2867                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
2868                                 ndr->offset = _relative_save_offset;
2869                         }
2870                         ndr->flags = _flags_save_string;
2871                 }
2872                 {
2873                         uint32_t _flags_save_string = ndr->flags;
2874                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2875                         if (r->data_type) {
2876                                 uint32_t _relative_save_offset;
2877                                 _relative_save_offset = ndr->offset;
2878                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
2879                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
2880                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
2881                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
2882                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
2883                                 ndr->offset = _relative_save_offset;
2884                         }
2885                         ndr->flags = _flags_save_string;
2886                 }
2887                 {
2888                         uint32_t _flags_save_string = ndr->flags;
2889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2890                         if (r->text_status) {
2891                                 uint32_t _relative_save_offset;
2892                                 _relative_save_offset = ndr->offset;
2893                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
2894                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
2895                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
2896                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
2897                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
2898                                 ndr->offset = _relative_save_offset;
2899                         }
2900                         ndr->flags = _flags_save_string;
2901                 }
2902         }
2903         return NDR_ERR_SUCCESS;
2904 }
2905
2906 _PUBLIC_ void ndr_print_spoolss_JobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo1 *r)
2907 {
2908         ndr_print_struct(ndr, name, "spoolss_JobInfo1");
2909         ndr->depth++;
2910         ndr_print_uint32(ndr, "job_id", r->job_id);
2911         ndr_print_ptr(ndr, "printer_name", r->printer_name);
2912         ndr->depth++;
2913         if (r->printer_name) {
2914                 ndr_print_string(ndr, "printer_name", r->printer_name);
2915         }
2916         ndr->depth--;
2917         ndr_print_ptr(ndr, "server_name", r->server_name);
2918         ndr->depth++;
2919         if (r->server_name) {
2920                 ndr_print_string(ndr, "server_name", r->server_name);
2921         }
2922         ndr->depth--;
2923         ndr_print_ptr(ndr, "user_name", r->user_name);
2924         ndr->depth++;
2925         if (r->user_name) {
2926                 ndr_print_string(ndr, "user_name", r->user_name);
2927         }
2928         ndr->depth--;
2929         ndr_print_ptr(ndr, "document_name", r->document_name);
2930         ndr->depth++;
2931         if (r->document_name) {
2932                 ndr_print_string(ndr, "document_name", r->document_name);
2933         }
2934         ndr->depth--;
2935         ndr_print_ptr(ndr, "data_type", r->data_type);
2936         ndr->depth++;
2937         if (r->data_type) {
2938                 ndr_print_string(ndr, "data_type", r->data_type);
2939         }
2940         ndr->depth--;
2941         ndr_print_ptr(ndr, "text_status", r->text_status);
2942         ndr->depth++;
2943         if (r->text_status) {
2944                 ndr_print_string(ndr, "text_status", r->text_status);
2945         }
2946         ndr->depth--;
2947         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
2948         ndr_print_uint32(ndr, "priority", r->priority);
2949         ndr_print_uint32(ndr, "position", r->position);
2950         ndr_print_uint32(ndr, "total_pages", r->total_pages);
2951         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
2952         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
2953         ndr->depth--;
2954 }
2955
2956 _PUBLIC_ size_t ndr_size_spoolss_JobInfo1(const struct spoolss_JobInfo1 *r, struct smb_iconv_convenience *ic, int flags)
2957 {
2958         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo1, ic);
2959 }
2960
2961 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo2 *r)
2962 {
2963         if (ndr_flags & NDR_SCALARS) {
2964                 NDR_CHECK(ndr_push_align(ndr, 4));
2965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
2966                 {
2967                         uint32_t _flags_save_string = ndr->flags;
2968                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2969                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
2970                         ndr->flags = _flags_save_string;
2971                 }
2972                 {
2973                         uint32_t _flags_save_string = ndr->flags;
2974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
2976                         ndr->flags = _flags_save_string;
2977                 }
2978                 {
2979                         uint32_t _flags_save_string = ndr->flags;
2980                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2981                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
2982                         ndr->flags = _flags_save_string;
2983                 }
2984                 {
2985                         uint32_t _flags_save_string = ndr->flags;
2986                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2987                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
2988                         ndr->flags = _flags_save_string;
2989                 }
2990                 {
2991                         uint32_t _flags_save_string = ndr->flags;
2992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2993                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
2994                         ndr->flags = _flags_save_string;
2995                 }
2996                 {
2997                         uint32_t _flags_save_string = ndr->flags;
2998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
2999                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3000                         ndr->flags = _flags_save_string;
3001                 }
3002                 {
3003                         uint32_t _flags_save_string = ndr->flags;
3004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3005                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3006                         ndr->flags = _flags_save_string;
3007                 }
3008                 {
3009                         uint32_t _flags_save_string = ndr->flags;
3010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3012                         ndr->flags = _flags_save_string;
3013                 }
3014                 {
3015                         uint32_t _flags_save_string = ndr->flags;
3016                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3017                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3018                         ndr->flags = _flags_save_string;
3019                 }
3020                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3021                 {
3022                         uint32_t _flags_save_string = ndr->flags;
3023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3024                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3025                         ndr->flags = _flags_save_string;
3026                 }
3027                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3028                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3032                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3035                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3038         }
3039         if (ndr_flags & NDR_BUFFERS) {
3040                 {
3041                         uint32_t _flags_save_string = ndr->flags;
3042                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3043                         if (r->printer_name) {
3044                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3045                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3046                         }
3047                         ndr->flags = _flags_save_string;
3048                 }
3049                 {
3050                         uint32_t _flags_save_string = ndr->flags;
3051                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3052                         if (r->server_name) {
3053                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3054                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3055                         }
3056                         ndr->flags = _flags_save_string;
3057                 }
3058                 {
3059                         uint32_t _flags_save_string = ndr->flags;
3060                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3061                         if (r->user_name) {
3062                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3063                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3064                         }
3065                         ndr->flags = _flags_save_string;
3066                 }
3067                 {
3068                         uint32_t _flags_save_string = ndr->flags;
3069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3070                         if (r->document_name) {
3071                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3072                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3073                         }
3074                         ndr->flags = _flags_save_string;
3075                 }
3076                 {
3077                         uint32_t _flags_save_string = ndr->flags;
3078                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3079                         if (r->notify_name) {
3080                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3081                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3082                         }
3083                         ndr->flags = _flags_save_string;
3084                 }
3085                 {
3086                         uint32_t _flags_save_string = ndr->flags;
3087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3088                         if (r->data_type) {
3089                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3090                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3091                         }
3092                         ndr->flags = _flags_save_string;
3093                 }
3094                 {
3095                         uint32_t _flags_save_string = ndr->flags;
3096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3097                         if (r->print_processor) {
3098                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3099                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3100                         }
3101                         ndr->flags = _flags_save_string;
3102                 }
3103                 {
3104                         uint32_t _flags_save_string = ndr->flags;
3105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3106                         if (r->parameters) {
3107                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3108                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3109                         }
3110                         ndr->flags = _flags_save_string;
3111                 }
3112                 {
3113                         uint32_t _flags_save_string = ndr->flags;
3114                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3115                         if (r->driver_name) {
3116                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3117                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3118                         }
3119                         ndr->flags = _flags_save_string;
3120                 }
3121                 if (r->devmode) {
3122                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3123                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3124                 }
3125                 {
3126                         uint32_t _flags_save_string = ndr->flags;
3127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3128                         if (r->text_status) {
3129                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3130                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3131                         }
3132                         ndr->flags = _flags_save_string;
3133                 }
3134                 if (r->secdesc) {
3135                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3136                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3137                 }
3138         }
3139         return NDR_ERR_SUCCESS;
3140 }
3141
3142 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo2 *r)
3143 {
3144         uint32_t _ptr_printer_name;
3145         TALLOC_CTX *_mem_save_printer_name_0;
3146         uint32_t _ptr_server_name;
3147         TALLOC_CTX *_mem_save_server_name_0;
3148         uint32_t _ptr_user_name;
3149         TALLOC_CTX *_mem_save_user_name_0;
3150         uint32_t _ptr_document_name;
3151         TALLOC_CTX *_mem_save_document_name_0;
3152         uint32_t _ptr_notify_name;
3153         TALLOC_CTX *_mem_save_notify_name_0;
3154         uint32_t _ptr_data_type;
3155         TALLOC_CTX *_mem_save_data_type_0;
3156         uint32_t _ptr_print_processor;
3157         TALLOC_CTX *_mem_save_print_processor_0;
3158         uint32_t _ptr_parameters;
3159         TALLOC_CTX *_mem_save_parameters_0;
3160         uint32_t _ptr_driver_name;
3161         TALLOC_CTX *_mem_save_driver_name_0;
3162         uint32_t _ptr_devmode;
3163         TALLOC_CTX *_mem_save_devmode_0;
3164         uint32_t _ptr_text_status;
3165         TALLOC_CTX *_mem_save_text_status_0;
3166         uint32_t _ptr_secdesc;
3167         TALLOC_CTX *_mem_save_secdesc_0;
3168         if (ndr_flags & NDR_SCALARS) {
3169                 NDR_CHECK(ndr_pull_align(ndr, 4));
3170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3171                 {
3172                         uint32_t _flags_save_string = ndr->flags;
3173                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3174                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3175                         if (_ptr_printer_name) {
3176                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3177                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3178                         } else {
3179                                 r->printer_name = NULL;
3180                         }
3181                         ndr->flags = _flags_save_string;
3182                 }
3183                 {
3184                         uint32_t _flags_save_string = ndr->flags;
3185                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3186                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3187                         if (_ptr_server_name) {
3188                                 NDR_PULL_ALLOC(ndr, r->server_name);
3189                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3190                         } else {
3191                                 r->server_name = NULL;
3192                         }
3193                         ndr->flags = _flags_save_string;
3194                 }
3195                 {
3196                         uint32_t _flags_save_string = ndr->flags;
3197                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3198                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3199                         if (_ptr_user_name) {
3200                                 NDR_PULL_ALLOC(ndr, r->user_name);
3201                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3202                         } else {
3203                                 r->user_name = NULL;
3204                         }
3205                         ndr->flags = _flags_save_string;
3206                 }
3207                 {
3208                         uint32_t _flags_save_string = ndr->flags;
3209                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3210                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3211                         if (_ptr_document_name) {
3212                                 NDR_PULL_ALLOC(ndr, r->document_name);
3213                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3214                         } else {
3215                                 r->document_name = NULL;
3216                         }
3217                         ndr->flags = _flags_save_string;
3218                 }
3219                 {
3220                         uint32_t _flags_save_string = ndr->flags;
3221                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3222                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3223                         if (_ptr_notify_name) {
3224                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3225                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3226                         } else {
3227                                 r->notify_name = NULL;
3228                         }
3229                         ndr->flags = _flags_save_string;
3230                 }
3231                 {
3232                         uint32_t _flags_save_string = ndr->flags;
3233                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3234                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3235                         if (_ptr_data_type) {
3236                                 NDR_PULL_ALLOC(ndr, r->data_type);
3237                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3238                         } else {
3239                                 r->data_type = NULL;
3240                         }
3241                         ndr->flags = _flags_save_string;
3242                 }
3243                 {
3244                         uint32_t _flags_save_string = ndr->flags;
3245                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3246                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3247                         if (_ptr_print_processor) {
3248                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3249                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3250                         } else {
3251                                 r->print_processor = NULL;
3252                         }
3253                         ndr->flags = _flags_save_string;
3254                 }
3255                 {
3256                         uint32_t _flags_save_string = ndr->flags;
3257                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3258                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3259                         if (_ptr_parameters) {
3260                                 NDR_PULL_ALLOC(ndr, r->parameters);
3261                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3262                         } else {
3263                                 r->parameters = NULL;
3264                         }
3265                         ndr->flags = _flags_save_string;
3266                 }
3267                 {
3268                         uint32_t _flags_save_string = ndr->flags;
3269                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3270                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3271                         if (_ptr_driver_name) {
3272                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3273                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3274                         } else {
3275                                 r->driver_name = NULL;
3276                         }
3277                         ndr->flags = _flags_save_string;
3278                 }
3279                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3280                 if (_ptr_devmode) {
3281                         NDR_PULL_ALLOC(ndr, r->devmode);
3282                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3283                 } else {
3284                         r->devmode = NULL;
3285                 }
3286                 {
3287                         uint32_t _flags_save_string = ndr->flags;
3288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3289                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3290                         if (_ptr_text_status) {
3291                                 NDR_PULL_ALLOC(ndr, r->text_status);
3292                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3293                         } else {
3294                                 r->text_status = NULL;
3295                         }
3296                         ndr->flags = _flags_save_string;
3297                 }
3298                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3299                 if (_ptr_secdesc) {
3300                         NDR_PULL_ALLOC(ndr, r->secdesc);
3301                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3302                 } else {
3303                         r->secdesc = NULL;
3304                 }
3305                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3307                 if (r->priority > 99) {
3308                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3309                 }
3310                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3312                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3315                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3318         }
3319         if (ndr_flags & NDR_BUFFERS) {
3320                 {
3321                         uint32_t _flags_save_string = ndr->flags;
3322                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3323                         if (r->printer_name) {
3324                                 uint32_t _relative_save_offset;
3325                                 _relative_save_offset = ndr->offset;
3326                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3327                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3328                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
3329                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
3330                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
3331                                 ndr->offset = _relative_save_offset;
3332                         }
3333                         ndr->flags = _flags_save_string;
3334                 }
3335                 {
3336                         uint32_t _flags_save_string = ndr->flags;
3337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3338                         if (r->server_name) {
3339                                 uint32_t _relative_save_offset;
3340                                 _relative_save_offset = ndr->offset;
3341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
3342                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3343                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
3344                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
3345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
3346                                 ndr->offset = _relative_save_offset;
3347                         }
3348                         ndr->flags = _flags_save_string;
3349                 }
3350                 {
3351                         uint32_t _flags_save_string = ndr->flags;
3352                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3353                         if (r->user_name) {
3354                                 uint32_t _relative_save_offset;
3355                                 _relative_save_offset = ndr->offset;
3356                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
3357                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3358                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
3359                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
3360                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
3361                                 ndr->offset = _relative_save_offset;
3362                         }
3363                         ndr->flags = _flags_save_string;
3364                 }
3365                 {
3366                         uint32_t _flags_save_string = ndr->flags;
3367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3368                         if (r->document_name) {
3369                                 uint32_t _relative_save_offset;
3370                                 _relative_save_offset = ndr->offset;
3371                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
3372                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3373                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
3374                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
3375                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
3376                                 ndr->offset = _relative_save_offset;
3377                         }
3378                         ndr->flags = _flags_save_string;
3379                 }
3380                 {
3381                         uint32_t _flags_save_string = ndr->flags;
3382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3383                         if (r->notify_name) {
3384                                 uint32_t _relative_save_offset;
3385                                 _relative_save_offset = ndr->offset;
3386                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
3387                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3388                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
3389                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
3390                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
3391                                 ndr->offset = _relative_save_offset;
3392                         }
3393                         ndr->flags = _flags_save_string;
3394                 }
3395                 {
3396                         uint32_t _flags_save_string = ndr->flags;
3397                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3398                         if (r->data_type) {
3399                                 uint32_t _relative_save_offset;
3400                                 _relative_save_offset = ndr->offset;
3401                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
3402                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
3403                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
3404                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
3405                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
3406                                 ndr->offset = _relative_save_offset;
3407                         }
3408                         ndr->flags = _flags_save_string;
3409                 }
3410                 {
3411                         uint32_t _flags_save_string = ndr->flags;
3412                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3413                         if (r->print_processor) {
3414                                 uint32_t _relative_save_offset;
3415                                 _relative_save_offset = ndr->offset;
3416                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
3417                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
3418                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
3419                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
3420                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
3421                                 ndr->offset = _relative_save_offset;
3422                         }
3423                         ndr->flags = _flags_save_string;
3424                 }
3425                 {
3426                         uint32_t _flags_save_string = ndr->flags;
3427                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3428                         if (r->parameters) {
3429                                 uint32_t _relative_save_offset;
3430                                 _relative_save_offset = ndr->offset;
3431                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
3432                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
3433                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
3434                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
3435                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
3436                                 ndr->offset = _relative_save_offset;
3437                         }
3438                         ndr->flags = _flags_save_string;
3439                 }
3440                 {
3441                         uint32_t _flags_save_string = ndr->flags;
3442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3443                         if (r->driver_name) {
3444                                 uint32_t _relative_save_offset;
3445                                 _relative_save_offset = ndr->offset;
3446                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
3447                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3448                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
3449                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
3450                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
3451                                 ndr->offset = _relative_save_offset;
3452                         }
3453                         ndr->flags = _flags_save_string;
3454                 }
3455                 if (r->devmode) {
3456                         uint32_t _relative_save_offset;
3457                         _relative_save_offset = ndr->offset;
3458                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
3459                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
3460                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
3461                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
3463                         ndr->offset = _relative_save_offset;
3464                 }
3465                 {
3466                         uint32_t _flags_save_string = ndr->flags;
3467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3468                         if (r->text_status) {
3469                                 uint32_t _relative_save_offset;
3470                                 _relative_save_offset = ndr->offset;
3471                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
3472                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
3473                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
3474                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
3475                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
3476                                 ndr->offset = _relative_save_offset;
3477                         }
3478                         ndr->flags = _flags_save_string;
3479                 }
3480                 if (r->secdesc) {
3481                         uint32_t _relative_save_offset;
3482                         _relative_save_offset = ndr->offset;
3483                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
3484                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
3485                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
3486                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3487                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
3488                         ndr->offset = _relative_save_offset;
3489                 }
3490         }
3491         return NDR_ERR_SUCCESS;
3492 }
3493
3494 _PUBLIC_ void ndr_print_spoolss_JobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo2 *r)
3495 {
3496         ndr_print_struct(ndr, name, "spoolss_JobInfo2");
3497         ndr->depth++;
3498         ndr_print_uint32(ndr, "job_id", r->job_id);
3499         ndr_print_ptr(ndr, "printer_name", r->printer_name);
3500         ndr->depth++;
3501         if (r->printer_name) {
3502                 ndr_print_string(ndr, "printer_name", r->printer_name);
3503         }
3504         ndr->depth--;
3505         ndr_print_ptr(ndr, "server_name", r->server_name);
3506         ndr->depth++;
3507         if (r->server_name) {
3508                 ndr_print_string(ndr, "server_name", r->server_name);
3509         }
3510         ndr->depth--;
3511         ndr_print_ptr(ndr, "user_name", r->user_name);
3512         ndr->depth++;
3513         if (r->user_name) {
3514                 ndr_print_string(ndr, "user_name", r->user_name);
3515         }
3516         ndr->depth--;
3517         ndr_print_ptr(ndr, "document_name", r->document_name);
3518         ndr->depth++;
3519         if (r->document_name) {
3520                 ndr_print_string(ndr, "document_name", r->document_name);
3521         }
3522         ndr->depth--;
3523         ndr_print_ptr(ndr, "notify_name", r->notify_name);
3524         ndr->depth++;
3525         if (r->notify_name) {
3526                 ndr_print_string(ndr, "notify_name", r->notify_name);
3527         }
3528         ndr->depth--;
3529         ndr_print_ptr(ndr, "data_type", r->data_type);
3530         ndr->depth++;
3531         if (r->data_type) {
3532                 ndr_print_string(ndr, "data_type", r->data_type);
3533         }
3534         ndr->depth--;
3535         ndr_print_ptr(ndr, "print_processor", r->print_processor);
3536         ndr->depth++;
3537         if (r->print_processor) {
3538                 ndr_print_string(ndr, "print_processor", r->print_processor);
3539         }
3540         ndr->depth--;
3541         ndr_print_ptr(ndr, "parameters", r->parameters);
3542         ndr->depth++;
3543         if (r->parameters) {
3544                 ndr_print_string(ndr, "parameters", r->parameters);
3545         }
3546         ndr->depth--;
3547         ndr_print_ptr(ndr, "driver_name", r->driver_name);
3548         ndr->depth++;
3549         if (r->driver_name) {
3550                 ndr_print_string(ndr, "driver_name", r->driver_name);
3551         }
3552         ndr->depth--;
3553         ndr_print_ptr(ndr, "devmode", r->devmode);
3554         ndr->depth++;
3555         if (r->devmode) {
3556                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
3557         }
3558         ndr->depth--;
3559         ndr_print_ptr(ndr, "text_status", r->text_status);
3560         ndr->depth++;
3561         if (r->text_status) {
3562                 ndr_print_string(ndr, "text_status", r->text_status);
3563         }
3564         ndr->depth--;
3565         ndr_print_ptr(ndr, "secdesc", r->secdesc);
3566         ndr->depth++;
3567         if (r->secdesc) {
3568                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
3569         }
3570         ndr->depth--;
3571         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
3572         ndr_print_uint32(ndr, "priority", r->priority);
3573         ndr_print_uint32(ndr, "position", r->position);
3574         ndr_print_uint32(ndr, "start_time", r->start_time);
3575         ndr_print_uint32(ndr, "until_time", r->until_time);
3576         ndr_print_uint32(ndr, "total_pages", r->total_pages);
3577         ndr_print_uint32(ndr, "size", r->size);
3578         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
3579         ndr_print_uint32(ndr, "time", r->time);
3580         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
3581         ndr->depth--;
3582 }
3583
3584 _PUBLIC_ size_t ndr_size_spoolss_JobInfo2(const struct spoolss_JobInfo2 *r, struct smb_iconv_convenience *ic, int flags)
3585 {
3586         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo2, ic);
3587 }
3588
3589 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo3 *r)
3590 {
3591         if (ndr_flags & NDR_SCALARS) {
3592                 NDR_CHECK(ndr_push_align(ndr, 4));
3593                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->next_job_id));
3595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
3596         }
3597         if (ndr_flags & NDR_BUFFERS) {
3598         }
3599         return NDR_ERR_SUCCESS;
3600 }
3601
3602 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo3 *r)
3603 {
3604         if (ndr_flags & NDR_SCALARS) {
3605                 NDR_CHECK(ndr_pull_align(ndr, 4));
3606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->next_job_id));
3608                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
3609         }
3610         if (ndr_flags & NDR_BUFFERS) {
3611         }
3612         return NDR_ERR_SUCCESS;
3613 }
3614
3615 _PUBLIC_ void ndr_print_spoolss_JobInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo3 *r)
3616 {
3617         ndr_print_struct(ndr, name, "spoolss_JobInfo3");
3618         ndr->depth++;
3619         ndr_print_uint32(ndr, "job_id", r->job_id);
3620         ndr_print_uint32(ndr, "next_job_id", r->next_job_id);
3621         ndr_print_uint32(ndr, "reserved", r->reserved);
3622         ndr->depth--;
3623 }
3624
3625 _PUBLIC_ size_t ndr_size_spoolss_JobInfo3(const struct spoolss_JobInfo3 *r, struct smb_iconv_convenience *ic, int flags)
3626 {
3627         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo3, ic);
3628 }
3629
3630 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfo4 *r)
3631 {
3632         if (ndr_flags & NDR_SCALARS) {
3633                 NDR_CHECK(ndr_push_align(ndr, 4));
3634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
3635                 {
3636                         uint32_t _flags_save_string = ndr->flags;
3637                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3638                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printer_name));
3639                         ndr->flags = _flags_save_string;
3640                 }
3641                 {
3642                         uint32_t _flags_save_string = ndr->flags;
3643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3644                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->server_name));
3645                         ndr->flags = _flags_save_string;
3646                 }
3647                 {
3648                         uint32_t _flags_save_string = ndr->flags;
3649                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3650                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->user_name));
3651                         ndr->flags = _flags_save_string;
3652                 }
3653                 {
3654                         uint32_t _flags_save_string = ndr->flags;
3655                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3656                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->document_name));
3657                         ndr->flags = _flags_save_string;
3658                 }
3659                 {
3660                         uint32_t _flags_save_string = ndr->flags;
3661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3662                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->notify_name));
3663                         ndr->flags = _flags_save_string;
3664                 }
3665                 {
3666                         uint32_t _flags_save_string = ndr->flags;
3667                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3668                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_type));
3669                         ndr->flags = _flags_save_string;
3670                 }
3671                 {
3672                         uint32_t _flags_save_string = ndr->flags;
3673                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3674                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
3675                         ndr->flags = _flags_save_string;
3676                 }
3677                 {
3678                         uint32_t _flags_save_string = ndr->flags;
3679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3680                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
3681                         ndr->flags = _flags_save_string;
3682                 }
3683                 {
3684                         uint32_t _flags_save_string = ndr->flags;
3685                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3686                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
3687                         ndr->flags = _flags_save_string;
3688                 }
3689                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
3690                 {
3691                         uint32_t _flags_save_string = ndr->flags;
3692                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3693                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->text_status));
3694                         ndr->flags = _flags_save_string;
3695                 }
3696                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
3697                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
3698                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
3699                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
3700                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
3701                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
3702                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
3703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
3704                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
3706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
3707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
3708         }
3709         if (ndr_flags & NDR_BUFFERS) {
3710                 {
3711                         uint32_t _flags_save_string = ndr->flags;
3712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3713                         if (r->printer_name) {
3714                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printer_name));
3715                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printer_name));
3716                         }
3717                         ndr->flags = _flags_save_string;
3718                 }
3719                 {
3720                         uint32_t _flags_save_string = ndr->flags;
3721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3722                         if (r->server_name) {
3723                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->server_name));
3724                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->server_name));
3725                         }
3726                         ndr->flags = _flags_save_string;
3727                 }
3728                 {
3729                         uint32_t _flags_save_string = ndr->flags;
3730                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3731                         if (r->user_name) {
3732                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->user_name));
3733                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->user_name));
3734                         }
3735                         ndr->flags = _flags_save_string;
3736                 }
3737                 {
3738                         uint32_t _flags_save_string = ndr->flags;
3739                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3740                         if (r->document_name) {
3741                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->document_name));
3742                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->document_name));
3743                         }
3744                         ndr->flags = _flags_save_string;
3745                 }
3746                 {
3747                         uint32_t _flags_save_string = ndr->flags;
3748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3749                         if (r->notify_name) {
3750                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->notify_name));
3751                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->notify_name));
3752                         }
3753                         ndr->flags = _flags_save_string;
3754                 }
3755                 {
3756                         uint32_t _flags_save_string = ndr->flags;
3757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3758                         if (r->data_type) {
3759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_type));
3760                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_type));
3761                         }
3762                         ndr->flags = _flags_save_string;
3763                 }
3764                 {
3765                         uint32_t _flags_save_string = ndr->flags;
3766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3767                         if (r->print_processor) {
3768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
3769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
3770                         }
3771                         ndr->flags = _flags_save_string;
3772                 }
3773                 {
3774                         uint32_t _flags_save_string = ndr->flags;
3775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3776                         if (r->parameters) {
3777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
3778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
3779                         }
3780                         ndr->flags = _flags_save_string;
3781                 }
3782                 {
3783                         uint32_t _flags_save_string = ndr->flags;
3784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3785                         if (r->driver_name) {
3786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
3787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
3788                         }
3789                         ndr->flags = _flags_save_string;
3790                 }
3791                 if (r->devmode) {
3792                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
3793                         NDR_CHECK(ndr_push_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
3794                 }
3795                 {
3796                         uint32_t _flags_save_string = ndr->flags;
3797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3798                         if (r->text_status) {
3799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->text_status));
3800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->text_status));
3801                         }
3802                         ndr->flags = _flags_save_string;
3803                 }
3804                 if (r->secdesc) {
3805                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
3806                         NDR_CHECK(ndr_push_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
3807                 }
3808         }
3809         return NDR_ERR_SUCCESS;
3810 }
3811
3812 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfo4 *r)
3813 {
3814         uint32_t _ptr_printer_name;
3815         TALLOC_CTX *_mem_save_printer_name_0;
3816         uint32_t _ptr_server_name;
3817         TALLOC_CTX *_mem_save_server_name_0;
3818         uint32_t _ptr_user_name;
3819         TALLOC_CTX *_mem_save_user_name_0;
3820         uint32_t _ptr_document_name;
3821         TALLOC_CTX *_mem_save_document_name_0;
3822         uint32_t _ptr_notify_name;
3823         TALLOC_CTX *_mem_save_notify_name_0;
3824         uint32_t _ptr_data_type;
3825         TALLOC_CTX *_mem_save_data_type_0;
3826         uint32_t _ptr_print_processor;
3827         TALLOC_CTX *_mem_save_print_processor_0;
3828         uint32_t _ptr_parameters;
3829         TALLOC_CTX *_mem_save_parameters_0;
3830         uint32_t _ptr_driver_name;
3831         TALLOC_CTX *_mem_save_driver_name_0;
3832         uint32_t _ptr_devmode;
3833         TALLOC_CTX *_mem_save_devmode_0;
3834         uint32_t _ptr_text_status;
3835         TALLOC_CTX *_mem_save_text_status_0;
3836         uint32_t _ptr_secdesc;
3837         TALLOC_CTX *_mem_save_secdesc_0;
3838         if (ndr_flags & NDR_SCALARS) {
3839                 NDR_CHECK(ndr_pull_align(ndr, 4));
3840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
3841                 {
3842                         uint32_t _flags_save_string = ndr->flags;
3843                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3844                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
3845                         if (_ptr_printer_name) {
3846                                 NDR_PULL_ALLOC(ndr, r->printer_name);
3847                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printer_name, _ptr_printer_name));
3848                         } else {
3849                                 r->printer_name = NULL;
3850                         }
3851                         ndr->flags = _flags_save_string;
3852                 }
3853                 {
3854                         uint32_t _flags_save_string = ndr->flags;
3855                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3856                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
3857                         if (_ptr_server_name) {
3858                                 NDR_PULL_ALLOC(ndr, r->server_name);
3859                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->server_name, _ptr_server_name));
3860                         } else {
3861                                 r->server_name = NULL;
3862                         }
3863                         ndr->flags = _flags_save_string;
3864                 }
3865                 {
3866                         uint32_t _flags_save_string = ndr->flags;
3867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3868                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
3869                         if (_ptr_user_name) {
3870                                 NDR_PULL_ALLOC(ndr, r->user_name);
3871                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->user_name, _ptr_user_name));
3872                         } else {
3873                                 r->user_name = NULL;
3874                         }
3875                         ndr->flags = _flags_save_string;
3876                 }
3877                 {
3878                         uint32_t _flags_save_string = ndr->flags;
3879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3880                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
3881                         if (_ptr_document_name) {
3882                                 NDR_PULL_ALLOC(ndr, r->document_name);
3883                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->document_name, _ptr_document_name));
3884                         } else {
3885                                 r->document_name = NULL;
3886                         }
3887                         ndr->flags = _flags_save_string;
3888                 }
3889                 {
3890                         uint32_t _flags_save_string = ndr->flags;
3891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3892                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
3893                         if (_ptr_notify_name) {
3894                                 NDR_PULL_ALLOC(ndr, r->notify_name);
3895                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->notify_name, _ptr_notify_name));
3896                         } else {
3897                                 r->notify_name = NULL;
3898                         }
3899                         ndr->flags = _flags_save_string;
3900                 }
3901                 {
3902                         uint32_t _flags_save_string = ndr->flags;
3903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
3905                         if (_ptr_data_type) {
3906                                 NDR_PULL_ALLOC(ndr, r->data_type);
3907                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_type, _ptr_data_type));
3908                         } else {
3909                                 r->data_type = NULL;
3910                         }
3911                         ndr->flags = _flags_save_string;
3912                 }
3913                 {
3914                         uint32_t _flags_save_string = ndr->flags;
3915                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3916                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
3917                         if (_ptr_print_processor) {
3918                                 NDR_PULL_ALLOC(ndr, r->print_processor);
3919                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
3920                         } else {
3921                                 r->print_processor = NULL;
3922                         }
3923                         ndr->flags = _flags_save_string;
3924                 }
3925                 {
3926                         uint32_t _flags_save_string = ndr->flags;
3927                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3928                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
3929                         if (_ptr_parameters) {
3930                                 NDR_PULL_ALLOC(ndr, r->parameters);
3931                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
3932                         } else {
3933                                 r->parameters = NULL;
3934                         }
3935                         ndr->flags = _flags_save_string;
3936                 }
3937                 {
3938                         uint32_t _flags_save_string = ndr->flags;
3939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3940                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
3941                         if (_ptr_driver_name) {
3942                                 NDR_PULL_ALLOC(ndr, r->driver_name);
3943                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
3944                         } else {
3945                                 r->driver_name = NULL;
3946                         }
3947                         ndr->flags = _flags_save_string;
3948                 }
3949                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
3950                 if (_ptr_devmode) {
3951                         NDR_PULL_ALLOC(ndr, r->devmode);
3952                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
3953                 } else {
3954                         r->devmode = NULL;
3955                 }
3956                 {
3957                         uint32_t _flags_save_string = ndr->flags;
3958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3959                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
3960                         if (_ptr_text_status) {
3961                                 NDR_PULL_ALLOC(ndr, r->text_status);
3962                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->text_status, _ptr_text_status));
3963                         } else {
3964                                 r->text_status = NULL;
3965                         }
3966                         ndr->flags = _flags_save_string;
3967                 }
3968                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
3969                 if (_ptr_secdesc) {
3970                         NDR_PULL_ALLOC(ndr, r->secdesc);
3971                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
3972                 } else {
3973                         r->secdesc = NULL;
3974                 }
3975                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
3976                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
3977                 if (r->priority > 99) {
3978                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
3979                 }
3980                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
3981                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
3982                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
3983                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
3984                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
3985                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
3986                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
3987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
3988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
3989         }
3990         if (ndr_flags & NDR_BUFFERS) {
3991                 {
3992                         uint32_t _flags_save_string = ndr->flags;
3993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
3994                         if (r->printer_name) {
3995                                 uint32_t _relative_save_offset;
3996                                 _relative_save_offset = ndr->offset;
3997                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printer_name));
3998                                 _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
3999                                 NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4000                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printer_name));
4001                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4002                                 ndr->offset = _relative_save_offset;
4003                         }
4004                         ndr->flags = _flags_save_string;
4005                 }
4006                 {
4007                         uint32_t _flags_save_string = ndr->flags;
4008                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4009                         if (r->server_name) {
4010                                 uint32_t _relative_save_offset;
4011                                 _relative_save_offset = ndr->offset;
4012                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->server_name));
4013                                 _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4014                                 NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4015                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->server_name));
4016                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4017                                 ndr->offset = _relative_save_offset;
4018                         }
4019                         ndr->flags = _flags_save_string;
4020                 }
4021                 {
4022                         uint32_t _flags_save_string = ndr->flags;
4023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4024                         if (r->user_name) {
4025                                 uint32_t _relative_save_offset;
4026                                 _relative_save_offset = ndr->offset;
4027                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->user_name));
4028                                 _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4029                                 NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4030                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->user_name));
4031                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4032                                 ndr->offset = _relative_save_offset;
4033                         }
4034                         ndr->flags = _flags_save_string;
4035                 }
4036                 {
4037                         uint32_t _flags_save_string = ndr->flags;
4038                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4039                         if (r->document_name) {
4040                                 uint32_t _relative_save_offset;
4041                                 _relative_save_offset = ndr->offset;
4042                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->document_name));
4043                                 _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4044                                 NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4045                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->document_name));
4046                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4047                                 ndr->offset = _relative_save_offset;
4048                         }
4049                         ndr->flags = _flags_save_string;
4050                 }
4051                 {
4052                         uint32_t _flags_save_string = ndr->flags;
4053                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4054                         if (r->notify_name) {
4055                                 uint32_t _relative_save_offset;
4056                                 _relative_save_offset = ndr->offset;
4057                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->notify_name));
4058                                 _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4059                                 NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4060                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->notify_name));
4061                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4062                                 ndr->offset = _relative_save_offset;
4063                         }
4064                         ndr->flags = _flags_save_string;
4065                 }
4066                 {
4067                         uint32_t _flags_save_string = ndr->flags;
4068                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4069                         if (r->data_type) {
4070                                 uint32_t _relative_save_offset;
4071                                 _relative_save_offset = ndr->offset;
4072                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_type));
4073                                 _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4074                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4075                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_type));
4076                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4077                                 ndr->offset = _relative_save_offset;
4078                         }
4079                         ndr->flags = _flags_save_string;
4080                 }
4081                 {
4082                         uint32_t _flags_save_string = ndr->flags;
4083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4084                         if (r->print_processor) {
4085                                 uint32_t _relative_save_offset;
4086                                 _relative_save_offset = ndr->offset;
4087                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
4088                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4089                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4090                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
4091                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4092                                 ndr->offset = _relative_save_offset;
4093                         }
4094                         ndr->flags = _flags_save_string;
4095                 }
4096                 {
4097                         uint32_t _flags_save_string = ndr->flags;
4098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4099                         if (r->parameters) {
4100                                 uint32_t _relative_save_offset;
4101                                 _relative_save_offset = ndr->offset;
4102                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->parameters));
4103                                 _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4104                                 NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4105                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->parameters));
4106                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4107                                 ndr->offset = _relative_save_offset;
4108                         }
4109                         ndr->flags = _flags_save_string;
4110                 }
4111                 {
4112                         uint32_t _flags_save_string = ndr->flags;
4113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4114                         if (r->driver_name) {
4115                                 uint32_t _relative_save_offset;
4116                                 _relative_save_offset = ndr->offset;
4117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
4118                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4119                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4120                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
4121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4122                                 ndr->offset = _relative_save_offset;
4123                         }
4124                         ndr->flags = _flags_save_string;
4125                 }
4126                 if (r->devmode) {
4127                         uint32_t _relative_save_offset;
4128                         _relative_save_offset = ndr->offset;
4129                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->devmode));
4130                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
4131                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
4132                         NDR_CHECK(ndr_pull_spoolss_DeviceMode(ndr, NDR_SCALARS, r->devmode));
4133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
4134                         ndr->offset = _relative_save_offset;
4135                 }
4136                 {
4137                         uint32_t _flags_save_string = ndr->flags;
4138                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
4139                         if (r->text_status) {
4140                                 uint32_t _relative_save_offset;
4141                                 _relative_save_offset = ndr->offset;
4142                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->text_status));
4143                                 _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4144                                 NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4145                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->text_status));
4146                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4147                                 ndr->offset = _relative_save_offset;
4148                         }
4149                         ndr->flags = _flags_save_string;
4150                 }
4151                 if (r->secdesc) {
4152                         uint32_t _relative_save_offset;
4153                         _relative_save_offset = ndr->offset;
4154                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->secdesc));
4155                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
4156                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
4157                         NDR_CHECK(ndr_pull_security_descriptor(ndr, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
4158                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
4159                         ndr->offset = _relative_save_offset;
4160                 }
4161         }
4162         return NDR_ERR_SUCCESS;
4163 }
4164
4165 _PUBLIC_ void ndr_print_spoolss_JobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfo4 *r)
4166 {
4167         ndr_print_struct(ndr, name, "spoolss_JobInfo4");
4168         ndr->depth++;
4169         ndr_print_uint32(ndr, "job_id", r->job_id);
4170         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4171         ndr->depth++;
4172         if (r->printer_name) {
4173                 ndr_print_string(ndr, "printer_name", r->printer_name);
4174         }
4175         ndr->depth--;
4176         ndr_print_ptr(ndr, "server_name", r->server_name);
4177         ndr->depth++;
4178         if (r->server_name) {
4179                 ndr_print_string(ndr, "server_name", r->server_name);
4180         }
4181         ndr->depth--;
4182         ndr_print_ptr(ndr, "user_name", r->user_name);
4183         ndr->depth++;
4184         if (r->user_name) {
4185                 ndr_print_string(ndr, "user_name", r->user_name);
4186         }
4187         ndr->depth--;
4188         ndr_print_ptr(ndr, "document_name", r->document_name);
4189         ndr->depth++;
4190         if (r->document_name) {
4191                 ndr_print_string(ndr, "document_name", r->document_name);
4192         }
4193         ndr->depth--;
4194         ndr_print_ptr(ndr, "notify_name", r->notify_name);
4195         ndr->depth++;
4196         if (r->notify_name) {
4197                 ndr_print_string(ndr, "notify_name", r->notify_name);
4198         }
4199         ndr->depth--;
4200         ndr_print_ptr(ndr, "data_type", r->data_type);
4201         ndr->depth++;
4202         if (r->data_type) {
4203                 ndr_print_string(ndr, "data_type", r->data_type);
4204         }
4205         ndr->depth--;
4206         ndr_print_ptr(ndr, "print_processor", r->print_processor);
4207         ndr->depth++;
4208         if (r->print_processor) {
4209                 ndr_print_string(ndr, "print_processor", r->print_processor);
4210         }
4211         ndr->depth--;
4212         ndr_print_ptr(ndr, "parameters", r->parameters);
4213         ndr->depth++;
4214         if (r->parameters) {
4215                 ndr_print_string(ndr, "parameters", r->parameters);
4216         }
4217         ndr->depth--;
4218         ndr_print_ptr(ndr, "driver_name", r->driver_name);
4219         ndr->depth++;
4220         if (r->driver_name) {
4221                 ndr_print_string(ndr, "driver_name", r->driver_name);
4222         }
4223         ndr->depth--;
4224         ndr_print_ptr(ndr, "devmode", r->devmode);
4225         ndr->depth++;
4226         if (r->devmode) {
4227                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
4228         }
4229         ndr->depth--;
4230         ndr_print_ptr(ndr, "text_status", r->text_status);
4231         ndr->depth++;
4232         if (r->text_status) {
4233                 ndr_print_string(ndr, "text_status", r->text_status);
4234         }
4235         ndr->depth--;
4236         ndr_print_ptr(ndr, "secdesc", r->secdesc);
4237         ndr->depth++;
4238         if (r->secdesc) {
4239                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
4240         }
4241         ndr->depth--;
4242         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4243         ndr_print_uint32(ndr, "priority", r->priority);
4244         ndr_print_uint32(ndr, "position", r->position);
4245         ndr_print_uint32(ndr, "start_time", r->start_time);
4246         ndr_print_uint32(ndr, "until_time", r->until_time);
4247         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4248         ndr_print_uint32(ndr, "size", r->size);
4249         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4250         ndr_print_uint32(ndr, "time", r->time);
4251         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4252         ndr_print_uint32(ndr, "size_high", r->size_high);
4253         ndr->depth--;
4254 }
4255
4256 _PUBLIC_ size_t ndr_size_spoolss_JobInfo4(const struct spoolss_JobInfo4 *r, struct smb_iconv_convenience *ic, int flags)
4257 {
4258         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo4, ic);
4259 }
4260
4261 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_JobInfo *r)
4262 {
4263         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
4264         if (ndr_flags & NDR_SCALARS) {
4265                 int level = ndr_push_get_switch_value(ndr, r);
4266                 switch (level) {
4267                         case 1: {
4268                                 NDR_CHECK(ndr_push_align(ndr, 4));
4269                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4270                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4271                         break; }
4272
4273                         case 2: {
4274                                 NDR_CHECK(ndr_push_align(ndr, 4));
4275                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4276                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4277                         break; }
4278
4279                         case 3: {
4280                                 NDR_CHECK(ndr_push_align(ndr, 4));
4281                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4282                                 NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4283                         break; }
4284
4285                         case 4: {
4286                                 NDR_CHECK(ndr_push_align(ndr, 4));
4287                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
4288                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4289                         break; }
4290
4291                         default: {
4292                         break; }
4293
4294                 }
4295         }
4296         if (ndr_flags & NDR_BUFFERS) {
4297                 int level = ndr_push_get_switch_value(ndr, r);
4298                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
4299                 switch (level) {
4300                         case 1:
4301                                 NDR_CHECK(ndr_push_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4302                         break;
4303
4304                         case 2:
4305                                 NDR_CHECK(ndr_push_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4306                         break;
4307
4308                         case 3:
4309                         break;
4310
4311                         case 4:
4312                                 NDR_CHECK(ndr_push_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4313                         break;
4314
4315                         default:
4316                         break;
4317
4318                 }
4319         }
4320         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
4321         return NDR_ERR_SUCCESS;
4322 }
4323
4324 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_JobInfo *r)
4325 {
4326         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
4327         int level;
4328         level = ndr_pull_get_switch_value(ndr, r);
4329         if (ndr_flags & NDR_SCALARS) {
4330                 switch (level) {
4331                         case 1: {
4332                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4333                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4334                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_SCALARS, &r->info1));
4335                         break; }
4336
4337                         case 2: {
4338                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4339                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4340                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_SCALARS, &r->info2));
4341                         break; }
4342
4343                         case 3: {
4344                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4345                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4346                                 NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, &r->info3));
4347                         break; }
4348
4349                         case 4: {
4350                                 NDR_CHECK(ndr_pull_align(ndr, 4));
4351                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
4352                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_SCALARS, &r->info4));
4353                         break; }
4354
4355                         default: {
4356                         break; }
4357
4358                 }
4359         }
4360         if (ndr_flags & NDR_BUFFERS) {
4361                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
4362                 switch (level) {
4363                         case 1:
4364                                 NDR_CHECK(ndr_pull_spoolss_JobInfo1(ndr, NDR_BUFFERS, &r->info1));
4365                         break;
4366
4367                         case 2:
4368                                 NDR_CHECK(ndr_pull_spoolss_JobInfo2(ndr, NDR_BUFFERS, &r->info2));
4369                         break;
4370
4371                         case 3:
4372                         break;
4373
4374                         case 4:
4375                                 NDR_CHECK(ndr_pull_spoolss_JobInfo4(ndr, NDR_BUFFERS, &r->info4));
4376                         break;
4377
4378                         default:
4379                         break;
4380
4381                 }
4382         }
4383         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
4384         return NDR_ERR_SUCCESS;
4385 }
4386
4387 _PUBLIC_ void ndr_print_spoolss_JobInfo(struct ndr_print *ndr, const char *name, const union spoolss_JobInfo *r)
4388 {
4389         int level;
4390         level = ndr_print_get_switch_value(ndr, r);
4391         ndr_print_union(ndr, name, level, "spoolss_JobInfo");
4392         switch (level) {
4393                 case 1:
4394                         ndr_print_spoolss_JobInfo1(ndr, "info1", &r->info1);
4395                 break;
4396
4397                 case 2:
4398                         ndr_print_spoolss_JobInfo2(ndr, "info2", &r->info2);
4399                 break;
4400
4401                 case 3:
4402                         ndr_print_spoolss_JobInfo3(ndr, "info3", &r->info3);
4403                 break;
4404
4405                 case 4:
4406                         ndr_print_spoolss_JobInfo4(ndr, "info4", &r->info4);
4407                 break;
4408
4409                 default:
4410                 break;
4411
4412         }
4413 }
4414
4415 _PUBLIC_ size_t ndr_size_spoolss_JobInfo(const union spoolss_JobInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
4416 {
4417         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_JobInfo, ic);
4418 }
4419
4420 static enum ndr_err_code ndr_push_spoolss_SetJobInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo1 *r)
4421 {
4422         if (ndr_flags & NDR_SCALARS) {
4423                 NDR_CHECK(ndr_push_align(ndr, 4));
4424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4426                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4427                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4429                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4430                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4431                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4432                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4436                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4437         }
4438         if (ndr_flags & NDR_BUFFERS) {
4439                 if (r->printer_name) {
4440                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4443                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4444                 }
4445                 if (r->server_name) {
4446                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4449                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4450                 }
4451                 if (r->user_name) {
4452                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4455                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4456                 }
4457                 if (r->document_name) {
4458                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4461                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4462                 }
4463                 if (r->data_type) {
4464                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4467                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4468                 }
4469                 if (r->text_status) {
4470                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4471                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4472                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4473                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4474                 }
4475         }
4476         return NDR_ERR_SUCCESS;
4477 }
4478
4479 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo1 *r)
4480 {
4481         uint32_t _ptr_printer_name;
4482         TALLOC_CTX *_mem_save_printer_name_0;
4483         uint32_t _ptr_server_name;
4484         TALLOC_CTX *_mem_save_server_name_0;
4485         uint32_t _ptr_user_name;
4486         TALLOC_CTX *_mem_save_user_name_0;
4487         uint32_t _ptr_document_name;
4488         TALLOC_CTX *_mem_save_document_name_0;
4489         uint32_t _ptr_data_type;
4490         TALLOC_CTX *_mem_save_data_type_0;
4491         uint32_t _ptr_text_status;
4492         TALLOC_CTX *_mem_save_text_status_0;
4493         if (ndr_flags & NDR_SCALARS) {
4494                 NDR_CHECK(ndr_pull_align(ndr, 4));
4495                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4496                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4497                 if (_ptr_printer_name) {
4498                         NDR_PULL_ALLOC(ndr, r->printer_name);
4499                 } else {
4500                         r->printer_name = NULL;
4501                 }
4502                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4503                 if (_ptr_server_name) {
4504                         NDR_PULL_ALLOC(ndr, r->server_name);
4505                 } else {
4506                         r->server_name = NULL;
4507                 }
4508                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4509                 if (_ptr_user_name) {
4510                         NDR_PULL_ALLOC(ndr, r->user_name);
4511                 } else {
4512                         r->user_name = NULL;
4513                 }
4514                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4515                 if (_ptr_document_name) {
4516                         NDR_PULL_ALLOC(ndr, r->document_name);
4517                 } else {
4518                         r->document_name = NULL;
4519                 }
4520                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4521                 if (_ptr_data_type) {
4522                         NDR_PULL_ALLOC(ndr, r->data_type);
4523                 } else {
4524                         r->data_type = NULL;
4525                 }
4526                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4527                 if (_ptr_text_status) {
4528                         NDR_PULL_ALLOC(ndr, r->text_status);
4529                 } else {
4530                         r->text_status = NULL;
4531                 }
4532                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4533                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4534                 if (r->priority > 99) {
4535                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4536                 }
4537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4540                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4541         }
4542         if (ndr_flags & NDR_BUFFERS) {
4543                 if (r->printer_name) {
4544                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4545                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4546                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4547                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4548                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4549                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
4550                         }
4551                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4552                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4553                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4554                 }
4555                 if (r->server_name) {
4556                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4557                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4558                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4559                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4560                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4561                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
4562                         }
4563                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4564                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4565                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4566                 }
4567                 if (r->user_name) {
4568                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4569                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4570                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4571                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4572                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4573                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4574                         }
4575                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4576                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4577                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4578                 }
4579                 if (r->document_name) {
4580                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4581                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4582                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4583                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4584                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4585                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
4586                         }
4587                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4588                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4589                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4590                 }
4591                 if (r->data_type) {
4592                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4593                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4594                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4595                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4596                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4597                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
4598                         }
4599                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4600                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4601                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4602                 }
4603                 if (r->text_status) {
4604                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4605                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4606                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4607                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4608                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4609                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
4610                         }
4611                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4612                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4613                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4614                 }
4615         }
4616         return NDR_ERR_SUCCESS;
4617 }
4618
4619 _PUBLIC_ void ndr_print_spoolss_SetJobInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo1 *r)
4620 {
4621         ndr_print_struct(ndr, name, "spoolss_SetJobInfo1");
4622         ndr->depth++;
4623         ndr_print_uint32(ndr, "job_id", r->job_id);
4624         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4625         ndr->depth++;
4626         if (r->printer_name) {
4627                 ndr_print_string(ndr, "printer_name", r->printer_name);
4628         }
4629         ndr->depth--;
4630         ndr_print_ptr(ndr, "server_name", r->server_name);
4631         ndr->depth++;
4632         if (r->server_name) {
4633                 ndr_print_string(ndr, "server_name", r->server_name);
4634         }
4635         ndr->depth--;
4636         ndr_print_ptr(ndr, "user_name", r->user_name);
4637         ndr->depth++;
4638         if (r->user_name) {
4639                 ndr_print_string(ndr, "user_name", r->user_name);
4640         }
4641         ndr->depth--;
4642         ndr_print_ptr(ndr, "document_name", r->document_name);
4643         ndr->depth++;
4644         if (r->document_name) {
4645                 ndr_print_string(ndr, "document_name", r->document_name);
4646         }
4647         ndr->depth--;
4648         ndr_print_ptr(ndr, "data_type", r->data_type);
4649         ndr->depth++;
4650         if (r->data_type) {
4651                 ndr_print_string(ndr, "data_type", r->data_type);
4652         }
4653         ndr->depth--;
4654         ndr_print_ptr(ndr, "text_status", r->text_status);
4655         ndr->depth++;
4656         if (r->text_status) {
4657                 ndr_print_string(ndr, "text_status", r->text_status);
4658         }
4659         ndr->depth--;
4660         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
4661         ndr_print_uint32(ndr, "priority", r->priority);
4662         ndr_print_uint32(ndr, "position", r->position);
4663         ndr_print_uint32(ndr, "total_pages", r->total_pages);
4664         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
4665         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
4666         ndr->depth--;
4667 }
4668
4669 static enum ndr_err_code ndr_push_spoolss_SetJobInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo2 *r)
4670 {
4671         if (ndr_flags & NDR_SCALARS) {
4672                 NDR_CHECK(ndr_push_align(ndr, 4));
4673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
4674                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
4675                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
4676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
4677                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
4678                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
4679                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
4680                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
4681                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
4682                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
4683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
4684                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
4685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
4686                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
4687                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
4688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
4689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
4690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
4691                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
4692                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
4693                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4694                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
4695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
4696         }
4697         if (ndr_flags & NDR_BUFFERS) {
4698                 if (r->printer_name) {
4699                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4700                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4701                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
4702                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4703                 }
4704                 if (r->server_name) {
4705                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
4708                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4709                 }
4710                 if (r->user_name) {
4711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
4714                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4715                 }
4716                 if (r->document_name) {
4717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
4720                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4721                 }
4722                 if (r->notify_name) {
4723                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
4726                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4727                 }
4728                 if (r->data_type) {
4729                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
4732                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4733                 }
4734                 if (r->print_processor) {
4735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
4738                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4739                 }
4740                 if (r->parameters) {
4741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
4744                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4745                 }
4746                 if (r->driver_name) {
4747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
4750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4751                 }
4752                 if (r->text_status) {
4753                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
4755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
4756                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
4757                 }
4758         }
4759         return NDR_ERR_SUCCESS;
4760 }
4761
4762 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo2 *r)
4763 {
4764         uint32_t _ptr_printer_name;
4765         TALLOC_CTX *_mem_save_printer_name_0;
4766         uint32_t _ptr_server_name;
4767         TALLOC_CTX *_mem_save_server_name_0;
4768         uint32_t _ptr_user_name;
4769         TALLOC_CTX *_mem_save_user_name_0;
4770         uint32_t _ptr_document_name;
4771         TALLOC_CTX *_mem_save_document_name_0;
4772         uint32_t _ptr_notify_name;
4773         TALLOC_CTX *_mem_save_notify_name_0;
4774         uint32_t _ptr_data_type;
4775         TALLOC_CTX *_mem_save_data_type_0;
4776         uint32_t _ptr_print_processor;
4777         TALLOC_CTX *_mem_save_print_processor_0;
4778         uint32_t _ptr_parameters;
4779         TALLOC_CTX *_mem_save_parameters_0;
4780         uint32_t _ptr_driver_name;
4781         TALLOC_CTX *_mem_save_driver_name_0;
4782         uint32_t _ptr_text_status;
4783         TALLOC_CTX *_mem_save_text_status_0;
4784         if (ndr_flags & NDR_SCALARS) {
4785                 NDR_CHECK(ndr_pull_align(ndr, 4));
4786                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
4787                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
4788                 if (_ptr_printer_name) {
4789                         NDR_PULL_ALLOC(ndr, r->printer_name);
4790                 } else {
4791                         r->printer_name = NULL;
4792                 }
4793                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
4794                 if (_ptr_server_name) {
4795                         NDR_PULL_ALLOC(ndr, r->server_name);
4796                 } else {
4797                         r->server_name = NULL;
4798                 }
4799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
4800                 if (_ptr_user_name) {
4801                         NDR_PULL_ALLOC(ndr, r->user_name);
4802                 } else {
4803                         r->user_name = NULL;
4804                 }
4805                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
4806                 if (_ptr_document_name) {
4807                         NDR_PULL_ALLOC(ndr, r->document_name);
4808                 } else {
4809                         r->document_name = NULL;
4810                 }
4811                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
4812                 if (_ptr_notify_name) {
4813                         NDR_PULL_ALLOC(ndr, r->notify_name);
4814                 } else {
4815                         r->notify_name = NULL;
4816                 }
4817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
4818                 if (_ptr_data_type) {
4819                         NDR_PULL_ALLOC(ndr, r->data_type);
4820                 } else {
4821                         r->data_type = NULL;
4822                 }
4823                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
4824                 if (_ptr_print_processor) {
4825                         NDR_PULL_ALLOC(ndr, r->print_processor);
4826                 } else {
4827                         r->print_processor = NULL;
4828                 }
4829                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
4830                 if (_ptr_parameters) {
4831                         NDR_PULL_ALLOC(ndr, r->parameters);
4832                 } else {
4833                         r->parameters = NULL;
4834                 }
4835                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
4836                 if (_ptr_driver_name) {
4837                         NDR_PULL_ALLOC(ndr, r->driver_name);
4838                 } else {
4839                         r->driver_name = NULL;
4840                 }
4841                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
4842                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
4843                 if (_ptr_text_status) {
4844                         NDR_PULL_ALLOC(ndr, r->text_status);
4845                 } else {
4846                         r->text_status = NULL;
4847                 }
4848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
4849                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
4850                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
4851                 if (r->priority > 99) {
4852                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
4853                 }
4854                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
4855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
4856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
4857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
4858                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
4859                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
4860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
4861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
4862         }
4863         if (ndr_flags & NDR_BUFFERS) {
4864                 if (r->printer_name) {
4865                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4866                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
4867                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
4868                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
4869                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
4870                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
4871                         }
4872                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
4873                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
4874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
4875                 }
4876                 if (r->server_name) {
4877                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4878                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
4879                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
4880                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
4881                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
4882                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
4883                         }
4884                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
4885                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
4886                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
4887                 }
4888                 if (r->user_name) {
4889                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4890                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
4891                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
4892                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
4893                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
4894                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
4895                         }
4896                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
4897                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
4898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
4899                 }
4900                 if (r->document_name) {
4901                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4902                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
4903                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
4904                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
4905                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
4906                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
4907                         }
4908                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
4909                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
4910                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
4911                 }
4912                 if (r->notify_name) {
4913                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4914                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
4915                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
4916                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
4917                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
4918                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
4919                         }
4920                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
4921                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
4922                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
4923                 }
4924                 if (r->data_type) {
4925                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
4926                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
4927                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
4928                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
4929                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
4930                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
4931                         }
4932                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
4933                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
4934                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
4935                 }
4936                 if (r->print_processor) {
4937                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
4938                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
4939                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
4940                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
4941                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
4942                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
4943                         }
4944                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
4945                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
4946                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
4947                 }
4948                 if (r->parameters) {
4949                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
4950                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
4951                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
4952                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
4953                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
4954                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
4955                         }
4956                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
4957                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
4958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
4959                 }
4960                 if (r->driver_name) {
4961                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
4962                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
4963                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
4964                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
4965                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
4966                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
4967                         }
4968                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
4969                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
4970                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
4971                 }
4972                 if (r->text_status) {
4973                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
4974                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
4975                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
4976                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
4977                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
4978                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
4979                         }
4980                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
4981                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
4982                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
4983                 }
4984         }
4985         return NDR_ERR_SUCCESS;
4986 }
4987
4988 _PUBLIC_ void ndr_print_spoolss_SetJobInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo2 *r)
4989 {
4990         ndr_print_struct(ndr, name, "spoolss_SetJobInfo2");
4991         ndr->depth++;
4992         ndr_print_uint32(ndr, "job_id", r->job_id);
4993         ndr_print_ptr(ndr, "printer_name", r->printer_name);
4994         ndr->depth++;
4995         if (r->printer_name) {
4996                 ndr_print_string(ndr, "printer_name", r->printer_name);
4997         }
4998         ndr->depth--;
4999         ndr_print_ptr(ndr, "server_name", r->server_name);
5000         ndr->depth++;
5001         if (r->server_name) {
5002                 ndr_print_string(ndr, "server_name", r->server_name);
5003         }
5004         ndr->depth--;
5005         ndr_print_ptr(ndr, "user_name", r->user_name);
5006         ndr->depth++;
5007         if (r->user_name) {
5008                 ndr_print_string(ndr, "user_name", r->user_name);
5009         }
5010         ndr->depth--;
5011         ndr_print_ptr(ndr, "document_name", r->document_name);
5012         ndr->depth++;
5013         if (r->document_name) {
5014                 ndr_print_string(ndr, "document_name", r->document_name);
5015         }
5016         ndr->depth--;
5017         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5018         ndr->depth++;
5019         if (r->notify_name) {
5020                 ndr_print_string(ndr, "notify_name", r->notify_name);
5021         }
5022         ndr->depth--;
5023         ndr_print_ptr(ndr, "data_type", r->data_type);
5024         ndr->depth++;
5025         if (r->data_type) {
5026                 ndr_print_string(ndr, "data_type", r->data_type);
5027         }
5028         ndr->depth--;
5029         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5030         ndr->depth++;
5031         if (r->print_processor) {
5032                 ndr_print_string(ndr, "print_processor", r->print_processor);
5033         }
5034         ndr->depth--;
5035         ndr_print_ptr(ndr, "parameters", r->parameters);
5036         ndr->depth++;
5037         if (r->parameters) {
5038                 ndr_print_string(ndr, "parameters", r->parameters);
5039         }
5040         ndr->depth--;
5041         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5042         ndr->depth++;
5043         if (r->driver_name) {
5044                 ndr_print_string(ndr, "driver_name", r->driver_name);
5045         }
5046         ndr->depth--;
5047         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5048         ndr_print_ptr(ndr, "text_status", r->text_status);
5049         ndr->depth++;
5050         if (r->text_status) {
5051                 ndr_print_string(ndr, "text_status", r->text_status);
5052         }
5053         ndr->depth--;
5054         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5055         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5056         ndr_print_uint32(ndr, "priority", r->priority);
5057         ndr_print_uint32(ndr, "position", r->position);
5058         ndr_print_uint32(ndr, "start_time", r->start_time);
5059         ndr_print_uint32(ndr, "until_time", r->until_time);
5060         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5061         ndr_print_uint32(ndr, "size", r->size);
5062         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5063         ndr_print_uint32(ndr, "time", r->time);
5064         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5065         ndr->depth--;
5066 }
5067
5068 static enum ndr_err_code ndr_push_spoolss_SetJobInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetJobInfo4 *r)
5069 {
5070         if (ndr_flags & NDR_SCALARS) {
5071                 NDR_CHECK(ndr_push_align(ndr, 4));
5072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
5073                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printer_name));
5074                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->server_name));
5075                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user_name));
5076                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
5077                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->notify_name));
5078                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_type));
5079                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
5080                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
5081                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
5082                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_devmode_ptr));
5083                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->text_status));
5084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->_secdesc_ptr));
5085                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->status));
5086                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
5087                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->position));
5088                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->start_time));
5089                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->until_time));
5090                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5091                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
5092                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5093                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->time));
5094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pages_printed));
5095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size_high));
5096         }
5097         if (ndr_flags & NDR_BUFFERS) {
5098                 if (r->printer_name) {
5099                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5100                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5101                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printer_name, CH_UTF16)));
5102                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printer_name, ndr_charset_length(r->printer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5103                 }
5104                 if (r->server_name) {
5105                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5106                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5107                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->server_name, CH_UTF16)));
5108                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->server_name, ndr_charset_length(r->server_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5109                 }
5110                 if (r->user_name) {
5111                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5112                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5113                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user_name, CH_UTF16)));
5114                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user_name, ndr_charset_length(r->user_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5115                 }
5116                 if (r->document_name) {
5117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5118                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
5120                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5121                 }
5122                 if (r->notify_name) {
5123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5124                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5125                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->notify_name, CH_UTF16)));
5126                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->notify_name, ndr_charset_length(r->notify_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5127                 }
5128                 if (r->data_type) {
5129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5130                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5131                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_type, CH_UTF16)));
5132                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_type, ndr_charset_length(r->data_type, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5133                 }
5134                 if (r->print_processor) {
5135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5136                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5137                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
5138                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5139                 }
5140                 if (r->parameters) {
5141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
5144                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5145                 }
5146                 if (r->driver_name) {
5147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5148                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5149                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
5150                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5151                 }
5152                 if (r->text_status) {
5153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5154                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5155                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->text_status, CH_UTF16)));
5156                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->text_status, ndr_charset_length(r->text_status, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5157                 }
5158         }
5159         return NDR_ERR_SUCCESS;
5160 }
5161
5162 static enum ndr_err_code ndr_pull_spoolss_SetJobInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetJobInfo4 *r)
5163 {
5164         uint32_t _ptr_printer_name;
5165         TALLOC_CTX *_mem_save_printer_name_0;
5166         uint32_t _ptr_server_name;
5167         TALLOC_CTX *_mem_save_server_name_0;
5168         uint32_t _ptr_user_name;
5169         TALLOC_CTX *_mem_save_user_name_0;
5170         uint32_t _ptr_document_name;
5171         TALLOC_CTX *_mem_save_document_name_0;
5172         uint32_t _ptr_notify_name;
5173         TALLOC_CTX *_mem_save_notify_name_0;
5174         uint32_t _ptr_data_type;
5175         TALLOC_CTX *_mem_save_data_type_0;
5176         uint32_t _ptr_print_processor;
5177         TALLOC_CTX *_mem_save_print_processor_0;
5178         uint32_t _ptr_parameters;
5179         TALLOC_CTX *_mem_save_parameters_0;
5180         uint32_t _ptr_driver_name;
5181         TALLOC_CTX *_mem_save_driver_name_0;
5182         uint32_t _ptr_text_status;
5183         TALLOC_CTX *_mem_save_text_status_0;
5184         if (ndr_flags & NDR_SCALARS) {
5185                 NDR_CHECK(ndr_pull_align(ndr, 4));
5186                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
5187                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printer_name));
5188                 if (_ptr_printer_name) {
5189                         NDR_PULL_ALLOC(ndr, r->printer_name);
5190                 } else {
5191                         r->printer_name = NULL;
5192                 }
5193                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
5194                 if (_ptr_server_name) {
5195                         NDR_PULL_ALLOC(ndr, r->server_name);
5196                 } else {
5197                         r->server_name = NULL;
5198                 }
5199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user_name));
5200                 if (_ptr_user_name) {
5201                         NDR_PULL_ALLOC(ndr, r->user_name);
5202                 } else {
5203                         r->user_name = NULL;
5204                 }
5205                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
5206                 if (_ptr_document_name) {
5207                         NDR_PULL_ALLOC(ndr, r->document_name);
5208                 } else {
5209                         r->document_name = NULL;
5210                 }
5211                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_name));
5212                 if (_ptr_notify_name) {
5213                         NDR_PULL_ALLOC(ndr, r->notify_name);
5214                 } else {
5215                         r->notify_name = NULL;
5216                 }
5217                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
5218                 if (_ptr_data_type) {
5219                         NDR_PULL_ALLOC(ndr, r->data_type);
5220                 } else {
5221                         r->data_type = NULL;
5222                 }
5223                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
5224                 if (_ptr_print_processor) {
5225                         NDR_PULL_ALLOC(ndr, r->print_processor);
5226                 } else {
5227                         r->print_processor = NULL;
5228                 }
5229                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
5230                 if (_ptr_parameters) {
5231                         NDR_PULL_ALLOC(ndr, r->parameters);
5232                 } else {
5233                         r->parameters = NULL;
5234                 }
5235                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
5236                 if (_ptr_driver_name) {
5237                         NDR_PULL_ALLOC(ndr, r->driver_name);
5238                 } else {
5239                         r->driver_name = NULL;
5240                 }
5241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_devmode_ptr));
5242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_text_status));
5243                 if (_ptr_text_status) {
5244                         NDR_PULL_ALLOC(ndr, r->text_status);
5245                 } else {
5246                         r->text_status = NULL;
5247                 }
5248                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_secdesc_ptr));
5249                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->status));
5250                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
5251                 if (r->priority > 99) {
5252                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
5253                 }
5254                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->position));
5255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->start_time));
5256                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->until_time));
5257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5258                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
5259                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->submitted));
5260                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->time));
5261                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pages_printed));
5262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size_high));
5263         }
5264         if (ndr_flags & NDR_BUFFERS) {
5265                 if (r->printer_name) {
5266                         _mem_save_printer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5267                         NDR_PULL_SET_MEM_CTX(ndr, r->printer_name, 0);
5268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printer_name));
5269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printer_name));
5270                         if (ndr_get_array_length(ndr, &r->printer_name) > ndr_get_array_size(ndr, &r->printer_name)) {
5271                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printer_name), ndr_get_array_length(ndr, &r->printer_name));
5272                         }
5273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t)));
5274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printer_name, ndr_get_array_length(ndr, &r->printer_name), sizeof(uint16_t), CH_UTF16));
5275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printer_name_0, 0);
5276                 }
5277                 if (r->server_name) {
5278                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5279                         NDR_PULL_SET_MEM_CTX(ndr, r->server_name, 0);
5280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->server_name));
5281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->server_name));
5282                         if (ndr_get_array_length(ndr, &r->server_name) > ndr_get_array_size(ndr, &r->server_name)) {
5283                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->server_name), ndr_get_array_length(ndr, &r->server_name));
5284                         }
5285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t)));
5286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->server_name, ndr_get_array_length(ndr, &r->server_name), sizeof(uint16_t), CH_UTF16));
5287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
5288                 }
5289                 if (r->user_name) {
5290                         _mem_save_user_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5291                         NDR_PULL_SET_MEM_CTX(ndr, r->user_name, 0);
5292                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user_name));
5293                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user_name));
5294                         if (ndr_get_array_length(ndr, &r->user_name) > ndr_get_array_size(ndr, &r->user_name)) {
5295                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user_name), ndr_get_array_length(ndr, &r->user_name));
5296                         }
5297                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t)));
5298                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user_name, ndr_get_array_length(ndr, &r->user_name), sizeof(uint16_t), CH_UTF16));
5299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_name_0, 0);
5300                 }
5301                 if (r->document_name) {
5302                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5303                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
5304                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
5305                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
5306                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
5307                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
5308                         }
5309                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
5310                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
5311                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
5312                 }
5313                 if (r->notify_name) {
5314                         _mem_save_notify_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5315                         NDR_PULL_SET_MEM_CTX(ndr, r->notify_name, 0);
5316                         NDR_CHECK(ndr_pull_array_size(ndr, &r->notify_name));
5317                         NDR_CHECK(ndr_pull_array_length(ndr, &r->notify_name));
5318                         if (ndr_get_array_length(ndr, &r->notify_name) > ndr_get_array_size(ndr, &r->notify_name)) {
5319                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->notify_name), ndr_get_array_length(ndr, &r->notify_name));
5320                         }
5321                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t)));
5322                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->notify_name, ndr_get_array_length(ndr, &r->notify_name), sizeof(uint16_t), CH_UTF16));
5323                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_name_0, 0);
5324                 }
5325                 if (r->data_type) {
5326                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
5327                         NDR_PULL_SET_MEM_CTX(ndr, r->data_type, 0);
5328                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_type));
5329                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_type));
5330                         if (ndr_get_array_length(ndr, &r->data_type) > ndr_get_array_size(ndr, &r->data_type)) {
5331                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_type), ndr_get_array_length(ndr, &r->data_type));
5332                         }
5333                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t)));
5334                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_type, ndr_get_array_length(ndr, &r->data_type), sizeof(uint16_t), CH_UTF16));
5335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
5336                 }
5337                 if (r->print_processor) {
5338                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
5339                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
5340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
5341                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
5342                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
5343                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
5344                         }
5345                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
5346                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
5347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
5348                 }
5349                 if (r->parameters) {
5350                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
5351                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
5352                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
5353                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
5354                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
5355                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
5356                         }
5357                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
5358                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
5359                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
5360                 }
5361                 if (r->driver_name) {
5362                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
5363                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
5364                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
5365                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
5366                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
5367                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
5368                         }
5369                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
5370                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
5371                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
5372                 }
5373                 if (r->text_status) {
5374                         _mem_save_text_status_0 = NDR_PULL_GET_MEM_CTX(ndr);
5375                         NDR_PULL_SET_MEM_CTX(ndr, r->text_status, 0);
5376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->text_status));
5377                         NDR_CHECK(ndr_pull_array_length(ndr, &r->text_status));
5378                         if (ndr_get_array_length(ndr, &r->text_status) > ndr_get_array_size(ndr, &r->text_status)) {
5379                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->text_status), ndr_get_array_length(ndr, &r->text_status));
5380                         }
5381                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t)));
5382                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->text_status, ndr_get_array_length(ndr, &r->text_status), sizeof(uint16_t), CH_UTF16));
5383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_text_status_0, 0);
5384                 }
5385         }
5386         return NDR_ERR_SUCCESS;
5387 }
5388
5389 _PUBLIC_ void ndr_print_spoolss_SetJobInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetJobInfo4 *r)
5390 {
5391         ndr_print_struct(ndr, name, "spoolss_SetJobInfo4");
5392         ndr->depth++;
5393         ndr_print_uint32(ndr, "job_id", r->job_id);
5394         ndr_print_ptr(ndr, "printer_name", r->printer_name);
5395         ndr->depth++;
5396         if (r->printer_name) {
5397                 ndr_print_string(ndr, "printer_name", r->printer_name);
5398         }
5399         ndr->depth--;
5400         ndr_print_ptr(ndr, "server_name", r->server_name);
5401         ndr->depth++;
5402         if (r->server_name) {
5403                 ndr_print_string(ndr, "server_name", r->server_name);
5404         }
5405         ndr->depth--;
5406         ndr_print_ptr(ndr, "user_name", r->user_name);
5407         ndr->depth++;
5408         if (r->user_name) {
5409                 ndr_print_string(ndr, "user_name", r->user_name);
5410         }
5411         ndr->depth--;
5412         ndr_print_ptr(ndr, "document_name", r->document_name);
5413         ndr->depth++;
5414         if (r->document_name) {
5415                 ndr_print_string(ndr, "document_name", r->document_name);
5416         }
5417         ndr->depth--;
5418         ndr_print_ptr(ndr, "notify_name", r->notify_name);
5419         ndr->depth++;
5420         if (r->notify_name) {
5421                 ndr_print_string(ndr, "notify_name", r->notify_name);
5422         }
5423         ndr->depth--;
5424         ndr_print_ptr(ndr, "data_type", r->data_type);
5425         ndr->depth++;
5426         if (r->data_type) {
5427                 ndr_print_string(ndr, "data_type", r->data_type);
5428         }
5429         ndr->depth--;
5430         ndr_print_ptr(ndr, "print_processor", r->print_processor);
5431         ndr->depth++;
5432         if (r->print_processor) {
5433                 ndr_print_string(ndr, "print_processor", r->print_processor);
5434         }
5435         ndr->depth--;
5436         ndr_print_ptr(ndr, "parameters", r->parameters);
5437         ndr->depth++;
5438         if (r->parameters) {
5439                 ndr_print_string(ndr, "parameters", r->parameters);
5440         }
5441         ndr->depth--;
5442         ndr_print_ptr(ndr, "driver_name", r->driver_name);
5443         ndr->depth++;
5444         if (r->driver_name) {
5445                 ndr_print_string(ndr, "driver_name", r->driver_name);
5446         }
5447         ndr->depth--;
5448         ndr_print_uint32(ndr, "_devmode_ptr", r->_devmode_ptr);
5449         ndr_print_ptr(ndr, "text_status", r->text_status);
5450         ndr->depth++;
5451         if (r->text_status) {
5452                 ndr_print_string(ndr, "text_status", r->text_status);
5453         }
5454         ndr->depth--;
5455         ndr_print_uint32(ndr, "_secdesc_ptr", r->_secdesc_ptr);
5456         ndr_print_spoolss_JobStatus(ndr, "status", r->status);
5457         ndr_print_uint32(ndr, "priority", r->priority);
5458         ndr_print_uint32(ndr, "position", r->position);
5459         ndr_print_uint32(ndr, "start_time", r->start_time);
5460         ndr_print_uint32(ndr, "until_time", r->until_time);
5461         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5462         ndr_print_uint32(ndr, "size", r->size);
5463         ndr_print_spoolss_Time(ndr, "submitted", &r->submitted);
5464         ndr_print_uint32(ndr, "time", r->time);
5465         ndr_print_uint32(ndr, "pages_printed", r->pages_printed);
5466         ndr_print_uint32(ndr, "size_high", r->size_high);
5467         ndr->depth--;
5468 }
5469
5470 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_SetJobInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetJobInfo *r)
5471 {
5472         if (ndr_flags & NDR_SCALARS) {
5473                 int level = ndr_push_get_switch_value(ndr, r);
5474                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
5475                 switch (level) {
5476                         case 1: {
5477                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
5478                         break; }
5479
5480                         case 2: {
5481                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
5482                         break; }
5483
5484                         case 3: {
5485                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
5486                         break; }
5487
5488                         case 4: {
5489                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
5490                         break; }
5491
5492                         default: {
5493                         break; }
5494
5495                 }
5496         }
5497         if (ndr_flags & NDR_BUFFERS) {
5498                 int level = ndr_push_get_switch_value(ndr, r);
5499                 switch (level) {
5500                         case 1:
5501                                 if (r->info1) {
5502                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5503                                 }
5504                         break;
5505
5506                         case 2:
5507                                 if (r->info2) {
5508                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5509                                 }
5510                         break;
5511
5512                         case 3:
5513                                 if (r->info3) {
5514                                         NDR_CHECK(ndr_push_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5515                                 }
5516                         break;
5517
5518                         case 4:
5519                                 if (r->info4) {
5520                                         NDR_CHECK(ndr_push_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5521                                 }
5522                         break;
5523
5524                         default:
5525                         break;
5526
5527                 }
5528         }
5529         return NDR_ERR_SUCCESS;
5530 }
5531
5532 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_SetJobInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetJobInfo *r)
5533 {
5534         int level;
5535         uint32_t _level;
5536         TALLOC_CTX *_mem_save_info1_0;
5537         TALLOC_CTX *_mem_save_info2_0;
5538         TALLOC_CTX *_mem_save_info3_0;
5539         TALLOC_CTX *_mem_save_info4_0;
5540         level = ndr_pull_get_switch_value(ndr, r);
5541         if (ndr_flags & NDR_SCALARS) {
5542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
5543                 if (_level != level) {
5544                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
5545                 }
5546                 switch (level) {
5547                         case 1: {
5548                                 uint32_t _ptr_info1;
5549                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
5550                                 if (_ptr_info1) {
5551                                         NDR_PULL_ALLOC(ndr, r->info1);
5552                                 } else {
5553                                         r->info1 = NULL;
5554                                 }
5555                         break; }
5556
5557                         case 2: {
5558                                 uint32_t _ptr_info2;
5559                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
5560                                 if (_ptr_info2) {
5561                                         NDR_PULL_ALLOC(ndr, r->info2);
5562                                 } else {
5563                                         r->info2 = NULL;
5564                                 }
5565                         break; }
5566
5567                         case 3: {
5568                                 uint32_t _ptr_info3;
5569                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
5570                                 if (_ptr_info3) {
5571                                         NDR_PULL_ALLOC(ndr, r->info3);
5572                                 } else {
5573                                         r->info3 = NULL;
5574                                 }
5575                         break; }
5576
5577                         case 4: {
5578                                 uint32_t _ptr_info4;
5579                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
5580                                 if (_ptr_info4) {
5581                                         NDR_PULL_ALLOC(ndr, r->info4);
5582                                 } else {
5583                                         r->info4 = NULL;
5584                                 }
5585                         break; }
5586
5587                         default: {
5588                         break; }
5589
5590                 }
5591         }
5592         if (ndr_flags & NDR_BUFFERS) {
5593                 switch (level) {
5594                         case 1:
5595                                 if (r->info1) {
5596                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
5597                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
5598                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
5599                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
5600                                 }
5601                         break;
5602
5603                         case 2:
5604                                 if (r->info2) {
5605                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
5606                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
5607                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
5608                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
5609                                 }
5610                         break;
5611
5612                         case 3:
5613                                 if (r->info3) {
5614                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
5615                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
5616                                         NDR_CHECK(ndr_pull_spoolss_JobInfo3(ndr, NDR_SCALARS, r->info3));
5617                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
5618                                 }
5619                         break;
5620
5621                         case 4:
5622                                 if (r->info4) {
5623                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
5624                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
5625                                         NDR_CHECK(ndr_pull_spoolss_SetJobInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
5626                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
5627                                 }
5628                         break;
5629
5630                         default:
5631                         break;
5632
5633                 }
5634         }
5635         return NDR_ERR_SUCCESS;
5636 }
5637
5638 _PUBLIC_ void ndr_print_spoolss_SetJobInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetJobInfo *r)
5639 {
5640         int level;
5641         level = ndr_print_get_switch_value(ndr, r);
5642         ndr_print_union(ndr, name, level, "spoolss_SetJobInfo");
5643         switch (level) {
5644                 case 1:
5645                         ndr_print_ptr(ndr, "info1", r->info1);
5646                         ndr->depth++;
5647                         if (r->info1) {
5648                                 ndr_print_spoolss_SetJobInfo1(ndr, "info1", r->info1);
5649                         }
5650                         ndr->depth--;
5651                 break;
5652
5653                 case 2:
5654                         ndr_print_ptr(ndr, "info2", r->info2);
5655                         ndr->depth++;
5656                         if (r->info2) {
5657                                 ndr_print_spoolss_SetJobInfo2(ndr, "info2", r->info2);
5658                         }
5659                         ndr->depth--;
5660                 break;
5661
5662                 case 3:
5663                         ndr_print_ptr(ndr, "info3", r->info3);
5664                         ndr->depth++;
5665                         if (r->info3) {
5666                                 ndr_print_spoolss_JobInfo3(ndr, "info3", r->info3);
5667                         }
5668                         ndr->depth--;
5669                 break;
5670
5671                 case 4:
5672                         ndr_print_ptr(ndr, "info4", r->info4);
5673                         ndr->depth++;
5674                         if (r->info4) {
5675                                 ndr_print_spoolss_SetJobInfo4(ndr, "info4", r->info4);
5676                         }
5677                         ndr->depth--;
5678                 break;
5679
5680                 default:
5681                 break;
5682
5683         }
5684 }
5685
5686 static enum ndr_err_code ndr_push_spoolss_JobInfoContainer(struct ndr_push *ndr, int ndr_flags, const struct spoolss_JobInfoContainer *r)
5687 {
5688         if (ndr_flags & NDR_SCALARS) {
5689                 NDR_CHECK(ndr_push_align(ndr, 4));
5690                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
5691                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
5692                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5693         }
5694         if (ndr_flags & NDR_BUFFERS) {
5695                 NDR_CHECK(ndr_push_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5696         }
5697         return NDR_ERR_SUCCESS;
5698 }
5699
5700 static enum ndr_err_code ndr_pull_spoolss_JobInfoContainer(struct ndr_pull *ndr, int ndr_flags, struct spoolss_JobInfoContainer *r)
5701 {
5702         if (ndr_flags & NDR_SCALARS) {
5703                 NDR_CHECK(ndr_pull_align(ndr, 4));
5704                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
5705                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
5706                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_SCALARS, &r->info));
5707         }
5708         if (ndr_flags & NDR_BUFFERS) {
5709                 NDR_CHECK(ndr_pull_spoolss_SetJobInfo(ndr, NDR_BUFFERS, &r->info));
5710         }
5711         return NDR_ERR_SUCCESS;
5712 }
5713
5714 _PUBLIC_ void ndr_print_spoolss_JobInfoContainer(struct ndr_print *ndr, const char *name, const struct spoolss_JobInfoContainer *r)
5715 {
5716         ndr_print_struct(ndr, name, "spoolss_JobInfoContainer");
5717         ndr->depth++;
5718         ndr_print_uint32(ndr, "level", r->level);
5719         ndr_print_set_switch_value(ndr, &r->info, r->level);
5720         ndr_print_spoolss_SetJobInfo(ndr, "info", &r->info);
5721         ndr->depth--;
5722 }
5723
5724 static enum ndr_err_code ndr_push_spoolss_JobControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobControl r)
5725 {
5726         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5727         return NDR_ERR_SUCCESS;
5728 }
5729
5730 static enum ndr_err_code ndr_pull_spoolss_JobControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobControl *r)
5731 {
5732         uint32_t v;
5733         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5734         *r = v;
5735         return NDR_ERR_SUCCESS;
5736 }
5737
5738 _PUBLIC_ void ndr_print_spoolss_JobControl(struct ndr_print *ndr, const char *name, enum spoolss_JobControl r)
5739 {
5740         const char *val = NULL;
5741
5742         switch (r) {
5743                 case SPOOLSS_JOB_CONTROL_PAUSE: val = "SPOOLSS_JOB_CONTROL_PAUSE"; break;
5744                 case SPOOLSS_JOB_CONTROL_RESUME: val = "SPOOLSS_JOB_CONTROL_RESUME"; break;
5745                 case SPOOLSS_JOB_CONTROL_CANCEL: val = "SPOOLSS_JOB_CONTROL_CANCEL"; break;
5746                 case SPOOLSS_JOB_CONTROL_RESTART: val = "SPOOLSS_JOB_CONTROL_RESTART"; break;
5747                 case SPOOLSS_JOB_CONTROL_DELETE: val = "SPOOLSS_JOB_CONTROL_DELETE"; break;
5748                 case SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER: val = "SPOOLSS_JOB_CONTROL_SEND_TO_PRINTER"; break;
5749                 case SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED: val = "SPOOLSS_JOB_CONTROL_LAST_PAGE_EJECTED"; break;
5750                 case SPOOLSS_JOB_CONTROL_RETAIN: val = "SPOOLSS_JOB_CONTROL_RETAIN"; break;
5751                 case SPOOLSS_JOB_CONTROL_RELEASE: val = "SPOOLSS_JOB_CONTROL_RELEASE"; break;
5752         }
5753         ndr_print_enum(ndr, name, "ENUM", val, r);
5754 }
5755
5756 static enum ndr_err_code ndr_push_spoolss_PrinterControl(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrinterControl r)
5757 {
5758         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
5759         return NDR_ERR_SUCCESS;
5760 }
5761
5762 static enum ndr_err_code ndr_pull_spoolss_PrinterControl(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrinterControl *r)
5763 {
5764         uint32_t v;
5765         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
5766         *r = v;
5767         return NDR_ERR_SUCCESS;
5768 }
5769
5770 _PUBLIC_ void ndr_print_spoolss_PrinterControl(struct ndr_print *ndr, const char *name, enum spoolss_PrinterControl r)
5771 {
5772         const char *val = NULL;
5773
5774         switch (r) {
5775                 case SPOOLSS_PRINTER_CONTROL_UNPAUSE: val = "SPOOLSS_PRINTER_CONTROL_UNPAUSE"; break;
5776                 case SPOOLSS_PRINTER_CONTROL_PAUSE: val = "SPOOLSS_PRINTER_CONTROL_PAUSE"; break;
5777                 case SPOOLSS_PRINTER_CONTROL_RESUME: val = "SPOOLSS_PRINTER_CONTROL_RESUME"; break;
5778                 case SPOOLSS_PRINTER_CONTROL_PURGE: val = "SPOOLSS_PRINTER_CONTROL_PURGE"; break;
5779                 case SPOOLSS_PRINTER_CONTROL_SET_STATUS: val = "SPOOLSS_PRINTER_CONTROL_SET_STATUS"; break;
5780         }
5781         ndr_print_enum(ndr, name, "ENUM", val, r);
5782 }
5783
5784 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo0 *r)
5785 {
5786         if (ndr_flags & NDR_SCALARS) {
5787                 NDR_CHECK(ndr_push_align(ndr, 4));
5788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
5789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
5790                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
5791                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
5792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
5793                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5794                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
5795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
5796                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
5797                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
5798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
5799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
5800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
5801                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
5802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
5803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_error));
5804                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
5805                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
5806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
5807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
5808                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
5809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->status));
5810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
5811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
5812                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
5813                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
5814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
5815                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
5816                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
5817         }
5818         if (ndr_flags & NDR_BUFFERS) {
5819                 if (r->servername) {
5820                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5821                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5822                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
5823                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5824                 }
5825                 if (r->printername) {
5826                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
5829                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5830                 }
5831         }
5832         return NDR_ERR_SUCCESS;
5833 }
5834
5835 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo0 *r)
5836 {
5837         uint32_t _ptr_servername;
5838         TALLOC_CTX *_mem_save_servername_0;
5839         uint32_t _ptr_printername;
5840         TALLOC_CTX *_mem_save_printername_0;
5841         if (ndr_flags & NDR_SCALARS) {
5842                 NDR_CHECK(ndr_pull_align(ndr, 4));
5843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
5844                 if (_ptr_servername) {
5845                         NDR_PULL_ALLOC(ndr, r->servername);
5846                 } else {
5847                         r->servername = NULL;
5848                 }
5849                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
5850                 if (_ptr_printername) {
5851                         NDR_PULL_ALLOC(ndr, r->printername);
5852                 } else {
5853                         r->printername = NULL;
5854                 }
5855                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
5856                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
5857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
5858                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
5859                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
5860                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
5861                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
5862                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
5863                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
5864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
5865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
5866                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
5867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
5868                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_error));
5869                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
5870                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
5871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
5872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
5873                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
5874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->status));
5875                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
5876                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
5877                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
5878                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
5879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
5880                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
5881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
5882         }
5883         if (ndr_flags & NDR_BUFFERS) {
5884                 if (r->servername) {
5885                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5886                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
5887                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
5888                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
5889                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
5890                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
5891                         }
5892                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
5893                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
5894                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
5895                 }
5896                 if (r->printername) {
5897                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
5898                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
5899                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
5900                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
5901                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
5902                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
5903                         }
5904                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
5905                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
5906                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
5907                 }
5908         }
5909         return NDR_ERR_SUCCESS;
5910 }
5911
5912 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo0 *r)
5913 {
5914         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo0");
5915         ndr->depth++;
5916         ndr_print_ptr(ndr, "servername", r->servername);
5917         ndr->depth++;
5918         if (r->servername) {
5919                 ndr_print_string(ndr, "servername", r->servername);
5920         }
5921         ndr->depth--;
5922         ndr_print_ptr(ndr, "printername", r->printername);
5923         ndr->depth++;
5924         if (r->printername) {
5925                 ndr_print_string(ndr, "printername", r->printername);
5926         }
5927         ndr->depth--;
5928         ndr_print_uint32(ndr, "cjobs", r->cjobs);
5929         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
5930         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
5931         ndr_print_spoolss_Time(ndr, "time", &r->time);
5932         ndr_print_uint32(ndr, "global_counter", r->global_counter);
5933         ndr_print_uint32(ndr, "total_pages", r->total_pages);
5934         ndr_print_uint32(ndr, "version", r->version);
5935         ndr_print_uint32(ndr, "free_build", r->free_build);
5936         ndr_print_uint32(ndr, "spooling", r->spooling);
5937         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
5938         ndr_print_uint32(ndr, "session_counter", r->session_counter);
5939         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
5940         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
5941         ndr_print_uint32(ndr, "job_error", r->job_error);
5942         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
5943         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
5944         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
5945         ndr_print_uint32(ndr, "change_id", r->change_id);
5946         ndr_print_WERROR(ndr, "last_error", r->last_error);
5947         ndr_print_uint32(ndr, "status", r->status);
5948         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
5949         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
5950         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
5951         ndr_print_uint16(ndr, "processor_level", r->processor_level);
5952         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
5953         ndr_print_uint32(ndr, "reserved2", r->reserved2);
5954         ndr_print_uint32(ndr, "reserved3", r->reserved3);
5955         ndr->depth--;
5956 }
5957
5958 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo1 *r)
5959 {
5960         if (ndr_flags & NDR_SCALARS) {
5961                 NDR_CHECK(ndr_push_align(ndr, 4));
5962                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
5963                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->name));
5965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5966         }
5967         if (ndr_flags & NDR_BUFFERS) {
5968                 if (r->description) {
5969                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5970                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, CH_UTF16)));
5972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5973                 }
5974                 if (r->name) {
5975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, CH_UTF16)));
5978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5979                 }
5980                 if (r->comment) {
5981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
5983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
5984                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5985                 }
5986         }
5987         return NDR_ERR_SUCCESS;
5988 }
5989
5990 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo1 *r)
5991 {
5992         uint32_t _ptr_description;
5993         TALLOC_CTX *_mem_save_description_0;
5994         uint32_t _ptr_name;
5995         TALLOC_CTX *_mem_save_name_0;
5996         uint32_t _ptr_comment;
5997         TALLOC_CTX *_mem_save_comment_0;
5998         if (ndr_flags & NDR_SCALARS) {
5999                 NDR_CHECK(ndr_pull_align(ndr, 4));
6000                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
6001                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6002                 if (_ptr_description) {
6003                         NDR_PULL_ALLOC(ndr, r->description);
6004                 } else {
6005                         r->description = NULL;
6006                 }
6007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
6008                 if (_ptr_name) {
6009                         NDR_PULL_ALLOC(ndr, r->name);
6010                 } else {
6011                         r->name = NULL;
6012                 }
6013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6014                 if (_ptr_comment) {
6015                         NDR_PULL_ALLOC(ndr, r->comment);
6016                 } else {
6017                         r->comment = NULL;
6018                 }
6019         }
6020         if (ndr_flags & NDR_BUFFERS) {
6021                 if (r->description) {
6022                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6023                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6026                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
6027                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->description), ndr_get_array_length(ndr, &r->description));
6028                         }
6029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
6032                 }
6033                 if (r->name) {
6034                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6035                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6038                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
6039                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->name), ndr_get_array_length(ndr, &r->name));
6040                         }
6041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6044                 }
6045                 if (r->comment) {
6046                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6047                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6048                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6049                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6050                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6051                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6052                         }
6053                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6054                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6055                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6056                 }
6057         }
6058         return NDR_ERR_SUCCESS;
6059 }
6060
6061 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo1 *r)
6062 {
6063         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo1");
6064         ndr->depth++;
6065         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
6066         ndr_print_ptr(ndr, "description", r->description);
6067         ndr->depth++;
6068         if (r->description) {
6069                 ndr_print_string(ndr, "description", r->description);
6070         }
6071         ndr->depth--;
6072         ndr_print_ptr(ndr, "name", r->name);
6073         ndr->depth++;
6074         if (r->name) {
6075                 ndr_print_string(ndr, "name", r->name);
6076         }
6077         ndr->depth--;
6078         ndr_print_ptr(ndr, "comment", r->comment);
6079         ndr->depth++;
6080         if (r->comment) {
6081                 ndr_print_string(ndr, "comment", r->comment);
6082         }
6083         ndr->depth--;
6084         ndr->depth--;
6085 }
6086
6087 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo2 *r)
6088 {
6089         if (ndr_flags & NDR_SCALARS) {
6090                 NDR_CHECK(ndr_push_align(ndr, 4));
6091                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6092                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6093                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sharename));
6094                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6095                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->drivername));
6096                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
6097                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->location));
6098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->devmode));
6099                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->sepfile));
6100                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printprocessor));
6101                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
6102                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->parameters));
6103                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->secdesc));
6104                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6105                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
6106                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
6107                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
6108                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
6109                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6110                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
6111                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
6112         }
6113         if (ndr_flags & NDR_BUFFERS) {
6114                 if (r->servername) {
6115                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6116                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6117                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6118                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6119                 }
6120                 if (r->printername) {
6121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6122                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6123                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6124                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6125                 }
6126                 if (r->sharename) {
6127                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6128                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6129                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sharename, CH_UTF16)));
6130                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sharename, ndr_charset_length(r->sharename, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6131                 }
6132                 if (r->portname) {
6133                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6134                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6135                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6136                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6137                 }
6138                 if (r->drivername) {
6139                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6140                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->drivername, CH_UTF16)));
6142                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->drivername, ndr_charset_length(r->drivername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6143                 }
6144                 if (r->comment) {
6145                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6146                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6147                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->comment, CH_UTF16)));
6148                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->comment, ndr_charset_length(r->comment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6149                 }
6150                 if (r->location) {
6151                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6152                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6153                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->location, CH_UTF16)));
6154                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->location, ndr_charset_length(r->location, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6155                 }
6156                 if (r->devmode) {
6157                         {
6158                                 struct ndr_push *_ndr_devmode;
6159                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6160                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6161                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
6162                         }
6163                 }
6164                 if (r->sepfile) {
6165                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->sepfile, CH_UTF16)));
6168                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->sepfile, ndr_charset_length(r->sepfile, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6169                 }
6170                 if (r->printprocessor) {
6171                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printprocessor, CH_UTF16)));
6174                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printprocessor, ndr_charset_length(r->printprocessor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6175                 }
6176                 if (r->datatype) {
6177                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
6180                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6181                 }
6182                 if (r->parameters) {
6183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->parameters, CH_UTF16)));
6186                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->parameters, ndr_charset_length(r->parameters, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6187                 }
6188                 if (r->secdesc) {
6189                         {
6190                                 struct ndr_push *_ndr_secdesc;
6191                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6192                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6193                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6194                         }
6195                 }
6196         }
6197         return NDR_ERR_SUCCESS;
6198 }
6199
6200 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo2 *r)
6201 {
6202         uint32_t _ptr_servername;
6203         TALLOC_CTX *_mem_save_servername_0;
6204         uint32_t _ptr_printername;
6205         TALLOC_CTX *_mem_save_printername_0;
6206         uint32_t _ptr_sharename;
6207         TALLOC_CTX *_mem_save_sharename_0;
6208         uint32_t _ptr_portname;
6209         TALLOC_CTX *_mem_save_portname_0;
6210         uint32_t _ptr_drivername;
6211         TALLOC_CTX *_mem_save_drivername_0;
6212         uint32_t _ptr_comment;
6213         TALLOC_CTX *_mem_save_comment_0;
6214         uint32_t _ptr_location;
6215         TALLOC_CTX *_mem_save_location_0;
6216         uint32_t _ptr_devmode;
6217         TALLOC_CTX *_mem_save_devmode_0;
6218         uint32_t _ptr_sepfile;
6219         TALLOC_CTX *_mem_save_sepfile_0;
6220         uint32_t _ptr_printprocessor;
6221         TALLOC_CTX *_mem_save_printprocessor_0;
6222         uint32_t _ptr_datatype;
6223         TALLOC_CTX *_mem_save_datatype_0;
6224         uint32_t _ptr_parameters;
6225         TALLOC_CTX *_mem_save_parameters_0;
6226         uint32_t _ptr_secdesc;
6227         TALLOC_CTX *_mem_save_secdesc_0;
6228         if (ndr_flags & NDR_SCALARS) {
6229                 NDR_CHECK(ndr_pull_align(ndr, 4));
6230                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6231                 if (_ptr_servername) {
6232                         NDR_PULL_ALLOC(ndr, r->servername);
6233                 } else {
6234                         r->servername = NULL;
6235                 }
6236                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6237                 if (_ptr_printername) {
6238                         NDR_PULL_ALLOC(ndr, r->printername);
6239                 } else {
6240                         r->printername = NULL;
6241                 }
6242                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
6243                 if (_ptr_sharename) {
6244                         NDR_PULL_ALLOC(ndr, r->sharename);
6245                 } else {
6246                         r->sharename = NULL;
6247                 }
6248                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6249                 if (_ptr_portname) {
6250                         NDR_PULL_ALLOC(ndr, r->portname);
6251                 } else {
6252                         r->portname = NULL;
6253                 }
6254                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
6255                 if (_ptr_drivername) {
6256                         NDR_PULL_ALLOC(ndr, r->drivername);
6257                 } else {
6258                         r->drivername = NULL;
6259                 }
6260                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
6261                 if (_ptr_comment) {
6262                         NDR_PULL_ALLOC(ndr, r->comment);
6263                 } else {
6264                         r->comment = NULL;
6265                 }
6266                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
6267                 if (_ptr_location) {
6268                         NDR_PULL_ALLOC(ndr, r->location);
6269                 } else {
6270                         r->location = NULL;
6271                 }
6272                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
6273                 if (_ptr_devmode) {
6274                         NDR_PULL_ALLOC(ndr, r->devmode);
6275                 } else {
6276                         r->devmode = NULL;
6277                 }
6278                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
6279                 if (_ptr_sepfile) {
6280                         NDR_PULL_ALLOC(ndr, r->sepfile);
6281                 } else {
6282                         r->sepfile = NULL;
6283                 }
6284                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
6285                 if (_ptr_printprocessor) {
6286                         NDR_PULL_ALLOC(ndr, r->printprocessor);
6287                 } else {
6288                         r->printprocessor = NULL;
6289                 }
6290                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
6291                 if (_ptr_datatype) {
6292                         NDR_PULL_ALLOC(ndr, r->datatype);
6293                 } else {
6294                         r->datatype = NULL;
6295                 }
6296                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
6297                 if (_ptr_parameters) {
6298                         NDR_PULL_ALLOC(ndr, r->parameters);
6299                 } else {
6300                         r->parameters = NULL;
6301                 }
6302                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
6303                 if (_ptr_secdesc) {
6304                         NDR_PULL_ALLOC(ndr, r->secdesc);
6305                 } else {
6306                         r->secdesc = NULL;
6307                 }
6308                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6309                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
6310                 if (r->priority > 99) {
6311                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
6312                 }
6313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->defaultpriority));
6314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->starttime));
6315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->untiltime));
6316                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
6318                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->averageppm));
6319         }
6320         if (ndr_flags & NDR_BUFFERS) {
6321                 if (r->servername) {
6322                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6323                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6324                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6325                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6326                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6327                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6328                         }
6329                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6330                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6331                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6332                 }
6333                 if (r->printername) {
6334                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6335                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6336                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6337                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6338                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6339                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6340                         }
6341                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6342                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6343                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6344                 }
6345                 if (r->sharename) {
6346                         _mem_save_sharename_0 = NDR_PULL_GET_MEM_CTX(ndr);
6347                         NDR_PULL_SET_MEM_CTX(ndr, r->sharename, 0);
6348                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sharename));
6349                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sharename));
6350                         if (ndr_get_array_length(ndr, &r->sharename) > ndr_get_array_size(ndr, &r->sharename)) {
6351                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sharename), ndr_get_array_length(ndr, &r->sharename));
6352                         }
6353                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t)));
6354                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sharename, ndr_get_array_length(ndr, &r->sharename), sizeof(uint16_t), CH_UTF16));
6355                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sharename_0, 0);
6356                 }
6357                 if (r->portname) {
6358                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6359                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6360                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6361                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6362                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6363                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6364                         }
6365                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6366                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6367                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6368                 }
6369                 if (r->drivername) {
6370                         _mem_save_drivername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6371                         NDR_PULL_SET_MEM_CTX(ndr, r->drivername, 0);
6372                         NDR_CHECK(ndr_pull_array_size(ndr, &r->drivername));
6373                         NDR_CHECK(ndr_pull_array_length(ndr, &r->drivername));
6374                         if (ndr_get_array_length(ndr, &r->drivername) > ndr_get_array_size(ndr, &r->drivername)) {
6375                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->drivername), ndr_get_array_length(ndr, &r->drivername));
6376                         }
6377                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t)));
6378                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->drivername, ndr_get_array_length(ndr, &r->drivername), sizeof(uint16_t), CH_UTF16));
6379                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_drivername_0, 0);
6380                 }
6381                 if (r->comment) {
6382                         _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
6383                         NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
6384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->comment));
6385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->comment));
6386                         if (ndr_get_array_length(ndr, &r->comment) > ndr_get_array_size(ndr, &r->comment)) {
6387                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->comment), ndr_get_array_length(ndr, &r->comment));
6388                         }
6389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t)));
6390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->comment, ndr_get_array_length(ndr, &r->comment), sizeof(uint16_t), CH_UTF16));
6391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
6392                 }
6393                 if (r->location) {
6394                         _mem_save_location_0 = NDR_PULL_GET_MEM_CTX(ndr);
6395                         NDR_PULL_SET_MEM_CTX(ndr, r->location, 0);
6396                         NDR_CHECK(ndr_pull_array_size(ndr, &r->location));
6397                         NDR_CHECK(ndr_pull_array_length(ndr, &r->location));
6398                         if (ndr_get_array_length(ndr, &r->location) > ndr_get_array_size(ndr, &r->location)) {
6399                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->location), ndr_get_array_length(ndr, &r->location));
6400                         }
6401                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t)));
6402                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->location, ndr_get_array_length(ndr, &r->location), sizeof(uint16_t), CH_UTF16));
6403                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_location_0, 0);
6404                 }
6405                 if (r->devmode) {
6406                         _mem_save_devmode_0 = NDR_PULL_GET_MEM_CTX(ndr);
6407                         NDR_PULL_SET_MEM_CTX(ndr, r->devmode, 0);
6408                         {
6409                                 struct ndr_pull *_ndr_devmode;
6410                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_devmode, 0, -1));
6411                                 NDR_CHECK(ndr_pull_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
6412                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_devmode, 0, -1));
6413                         }
6414                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_0, 0);
6415                 }
6416                 if (r->sepfile) {
6417                         _mem_save_sepfile_0 = NDR_PULL_GET_MEM_CTX(ndr);
6418                         NDR_PULL_SET_MEM_CTX(ndr, r->sepfile, 0);
6419                         NDR_CHECK(ndr_pull_array_size(ndr, &r->sepfile));
6420                         NDR_CHECK(ndr_pull_array_length(ndr, &r->sepfile));
6421                         if (ndr_get_array_length(ndr, &r->sepfile) > ndr_get_array_size(ndr, &r->sepfile)) {
6422                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->sepfile), ndr_get_array_length(ndr, &r->sepfile));
6423                         }
6424                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t)));
6425                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->sepfile, ndr_get_array_length(ndr, &r->sepfile), sizeof(uint16_t), CH_UTF16));
6426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_sepfile_0, 0);
6427                 }
6428                 if (r->printprocessor) {
6429                         _mem_save_printprocessor_0 = NDR_PULL_GET_MEM_CTX(ndr);
6430                         NDR_PULL_SET_MEM_CTX(ndr, r->printprocessor, 0);
6431                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printprocessor));
6432                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printprocessor));
6433                         if (ndr_get_array_length(ndr, &r->printprocessor) > ndr_get_array_size(ndr, &r->printprocessor)) {
6434                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printprocessor), ndr_get_array_length(ndr, &r->printprocessor));
6435                         }
6436                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t)));
6437                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printprocessor, ndr_get_array_length(ndr, &r->printprocessor), sizeof(uint16_t), CH_UTF16));
6438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printprocessor_0, 0);
6439                 }
6440                 if (r->datatype) {
6441                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
6442                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
6443                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
6444                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
6445                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
6446                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
6447                         }
6448                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
6449                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
6450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
6451                 }
6452                 if (r->parameters) {
6453                         _mem_save_parameters_0 = NDR_PULL_GET_MEM_CTX(ndr);
6454                         NDR_PULL_SET_MEM_CTX(ndr, r->parameters, 0);
6455                         NDR_CHECK(ndr_pull_array_size(ndr, &r->parameters));
6456                         NDR_CHECK(ndr_pull_array_length(ndr, &r->parameters));
6457                         if (ndr_get_array_length(ndr, &r->parameters) > ndr_get_array_size(ndr, &r->parameters)) {
6458                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->parameters), ndr_get_array_length(ndr, &r->parameters));
6459                         }
6460                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t)));
6461                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->parameters, ndr_get_array_length(ndr, &r->parameters), sizeof(uint16_t), CH_UTF16));
6462                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_parameters_0, 0);
6463                 }
6464                 if (r->secdesc) {
6465                         _mem_save_secdesc_0 = NDR_PULL_GET_MEM_CTX(ndr);
6466                         NDR_PULL_SET_MEM_CTX(ndr, r->secdesc, 0);
6467                         {
6468                                 struct ndr_pull *_ndr_secdesc;
6469                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
6470                                 NDR_CHECK(ndr_pull_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
6471                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_secdesc, 0, -1));
6472                         }
6473                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_0, 0);
6474                 }
6475         }
6476         return NDR_ERR_SUCCESS;
6477 }
6478
6479 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo2 *r)
6480 {
6481         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo2");
6482         ndr->depth++;
6483         ndr_print_ptr(ndr, "servername", r->servername);
6484         ndr->depth++;
6485         if (r->servername) {
6486                 ndr_print_string(ndr, "servername", r->servername);
6487         }
6488         ndr->depth--;
6489         ndr_print_ptr(ndr, "printername", r->printername);
6490         ndr->depth++;
6491         if (r->printername) {
6492                 ndr_print_string(ndr, "printername", r->printername);
6493         }
6494         ndr->depth--;
6495         ndr_print_ptr(ndr, "sharename", r->sharename);
6496         ndr->depth++;
6497         if (r->sharename) {
6498                 ndr_print_string(ndr, "sharename", r->sharename);
6499         }
6500         ndr->depth--;
6501         ndr_print_ptr(ndr, "portname", r->portname);
6502         ndr->depth++;
6503         if (r->portname) {
6504                 ndr_print_string(ndr, "portname", r->portname);
6505         }
6506         ndr->depth--;
6507         ndr_print_ptr(ndr, "drivername", r->drivername);
6508         ndr->depth++;
6509         if (r->drivername) {
6510                 ndr_print_string(ndr, "drivername", r->drivername);
6511         }
6512         ndr->depth--;
6513         ndr_print_ptr(ndr, "comment", r->comment);
6514         ndr->depth++;
6515         if (r->comment) {
6516                 ndr_print_string(ndr, "comment", r->comment);
6517         }
6518         ndr->depth--;
6519         ndr_print_ptr(ndr, "location", r->location);
6520         ndr->depth++;
6521         if (r->location) {
6522                 ndr_print_string(ndr, "location", r->location);
6523         }
6524         ndr->depth--;
6525         ndr_print_ptr(ndr, "devmode", r->devmode);
6526         ndr->depth++;
6527         if (r->devmode) {
6528                 ndr_print_spoolss_DeviceMode(ndr, "devmode", r->devmode);
6529         }
6530         ndr->depth--;
6531         ndr_print_ptr(ndr, "sepfile", r->sepfile);
6532         ndr->depth++;
6533         if (r->sepfile) {
6534                 ndr_print_string(ndr, "sepfile", r->sepfile);
6535         }
6536         ndr->depth--;
6537         ndr_print_ptr(ndr, "printprocessor", r->printprocessor);
6538         ndr->depth++;
6539         if (r->printprocessor) {
6540                 ndr_print_string(ndr, "printprocessor", r->printprocessor);
6541         }
6542         ndr->depth--;
6543         ndr_print_ptr(ndr, "datatype", r->datatype);
6544         ndr->depth++;
6545         if (r->datatype) {
6546                 ndr_print_string(ndr, "datatype", r->datatype);
6547         }
6548         ndr->depth--;
6549         ndr_print_ptr(ndr, "parameters", r->parameters);
6550         ndr->depth++;
6551         if (r->parameters) {
6552                 ndr_print_string(ndr, "parameters", r->parameters);
6553         }
6554         ndr->depth--;
6555         ndr_print_ptr(ndr, "secdesc", r->secdesc);
6556         ndr->depth++;
6557         if (r->secdesc) {
6558                 ndr_print_security_descriptor(ndr, "secdesc", r->secdesc);
6559         }
6560         ndr->depth--;
6561         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6562         ndr_print_uint32(ndr, "priority", r->priority);
6563         ndr_print_uint32(ndr, "defaultpriority", r->defaultpriority);
6564         ndr_print_uint32(ndr, "starttime", r->starttime);
6565         ndr_print_uint32(ndr, "untiltime", r->untiltime);
6566         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6567         ndr_print_uint32(ndr, "cjobs", r->cjobs);
6568         ndr_print_uint32(ndr, "averageppm", r->averageppm);
6569         ndr->depth--;
6570 }
6571
6572 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo3 *r)
6573 {
6574         if (ndr_flags & NDR_SCALARS) {
6575                 NDR_CHECK(ndr_push_align(ndr, 4));
6576                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->sec_desc_ptr));
6577         }
6578         if (ndr_flags & NDR_BUFFERS) {
6579         }
6580         return NDR_ERR_SUCCESS;
6581 }
6582
6583 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo3 *r)
6584 {
6585         if (ndr_flags & NDR_SCALARS) {
6586                 NDR_CHECK(ndr_pull_align(ndr, 4));
6587                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->sec_desc_ptr));
6588         }
6589         if (ndr_flags & NDR_BUFFERS) {
6590         }
6591         return NDR_ERR_SUCCESS;
6592 }
6593
6594 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo3 *r)
6595 {
6596         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo3");
6597         ndr->depth++;
6598         ndr_print_uint32(ndr, "sec_desc_ptr", r->sec_desc_ptr);
6599         ndr->depth--;
6600 }
6601
6602 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo4 *r)
6603 {
6604         if (ndr_flags & NDR_SCALARS) {
6605                 NDR_CHECK(ndr_push_align(ndr, 4));
6606                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6607                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->servername));
6608                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6609         }
6610         if (ndr_flags & NDR_BUFFERS) {
6611                 if (r->printername) {
6612                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6613                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6614                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6615                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6616                 }
6617                 if (r->servername) {
6618                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6619                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6620                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->servername, CH_UTF16)));
6621                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->servername, ndr_charset_length(r->servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6622                 }
6623         }
6624         return NDR_ERR_SUCCESS;
6625 }
6626
6627 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo4 *r)
6628 {
6629         uint32_t _ptr_printername;
6630         TALLOC_CTX *_mem_save_printername_0;
6631         uint32_t _ptr_servername;
6632         TALLOC_CTX *_mem_save_servername_0;
6633         if (ndr_flags & NDR_SCALARS) {
6634                 NDR_CHECK(ndr_pull_align(ndr, 4));
6635                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6636                 if (_ptr_printername) {
6637                         NDR_PULL_ALLOC(ndr, r->printername);
6638                 } else {
6639                         r->printername = NULL;
6640                 }
6641                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
6642                 if (_ptr_servername) {
6643                         NDR_PULL_ALLOC(ndr, r->servername);
6644                 } else {
6645                         r->servername = NULL;
6646                 }
6647                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6648         }
6649         if (ndr_flags & NDR_BUFFERS) {
6650                 if (r->printername) {
6651                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6652                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6653                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6654                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6655                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6656                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6657                         }
6658                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6659                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6660                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6661                 }
6662                 if (r->servername) {
6663                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6664                         NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
6665                         NDR_CHECK(ndr_pull_array_size(ndr, &r->servername));
6666                         NDR_CHECK(ndr_pull_array_length(ndr, &r->servername));
6667                         if (ndr_get_array_length(ndr, &r->servername) > ndr_get_array_size(ndr, &r->servername)) {
6668                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->servername), ndr_get_array_length(ndr, &r->servername));
6669                         }
6670                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t)));
6671                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->servername, ndr_get_array_length(ndr, &r->servername), sizeof(uint16_t), CH_UTF16));
6672                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
6673                 }
6674         }
6675         return NDR_ERR_SUCCESS;
6676 }
6677
6678 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo4 *r)
6679 {
6680         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo4");
6681         ndr->depth++;
6682         ndr_print_ptr(ndr, "printername", r->printername);
6683         ndr->depth++;
6684         if (r->printername) {
6685                 ndr_print_string(ndr, "printername", r->printername);
6686         }
6687         ndr->depth--;
6688         ndr_print_ptr(ndr, "servername", r->servername);
6689         ndr->depth++;
6690         if (r->servername) {
6691                 ndr_print_string(ndr, "servername", r->servername);
6692         }
6693         ndr->depth--;
6694         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6695         ndr->depth--;
6696 }
6697
6698 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo5 *r)
6699 {
6700         if (ndr_flags & NDR_SCALARS) {
6701                 NDR_CHECK(ndr_push_align(ndr, 4));
6702                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->printername));
6703                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->portname));
6704                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
6705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->device_not_selected_timeout));
6706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->transmission_retry_timeout));
6707         }
6708         if (ndr_flags & NDR_BUFFERS) {
6709                 if (r->printername) {
6710                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6711                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6712                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->printername, CH_UTF16)));
6713                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->printername, ndr_charset_length(r->printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6714                 }
6715                 if (r->portname) {
6716                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->portname, CH_UTF16)));
6719                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, ndr_charset_length(r->portname, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6720                 }
6721         }
6722         return NDR_ERR_SUCCESS;
6723 }
6724
6725 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo5 *r)
6726 {
6727         uint32_t _ptr_printername;
6728         TALLOC_CTX *_mem_save_printername_0;
6729         uint32_t _ptr_portname;
6730         TALLOC_CTX *_mem_save_portname_0;
6731         if (ndr_flags & NDR_SCALARS) {
6732                 NDR_CHECK(ndr_pull_align(ndr, 4));
6733                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
6734                 if (_ptr_printername) {
6735                         NDR_PULL_ALLOC(ndr, r->printername);
6736                 } else {
6737                         r->printername = NULL;
6738                 }
6739                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
6740                 if (_ptr_portname) {
6741                         NDR_PULL_ALLOC(ndr, r->portname);
6742                 } else {
6743                         r->portname = NULL;
6744                 }
6745                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
6746                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->device_not_selected_timeout));
6747                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->transmission_retry_timeout));
6748         }
6749         if (ndr_flags & NDR_BUFFERS) {
6750                 if (r->printername) {
6751                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
6752                         NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
6753                         NDR_CHECK(ndr_pull_array_size(ndr, &r->printername));
6754                         NDR_CHECK(ndr_pull_array_length(ndr, &r->printername));
6755                         if (ndr_get_array_length(ndr, &r->printername) > ndr_get_array_size(ndr, &r->printername)) {
6756                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->printername), ndr_get_array_length(ndr, &r->printername));
6757                         }
6758                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t)));
6759                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->printername, ndr_get_array_length(ndr, &r->printername), sizeof(uint16_t), CH_UTF16));
6760                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
6761                 }
6762                 if (r->portname) {
6763                         _mem_save_portname_0 = NDR_PULL_GET_MEM_CTX(ndr);
6764                         NDR_PULL_SET_MEM_CTX(ndr, r->portname, 0);
6765                         NDR_CHECK(ndr_pull_array_size(ndr, &r->portname));
6766                         NDR_CHECK(ndr_pull_array_length(ndr, &r->portname));
6767                         if (ndr_get_array_length(ndr, &r->portname) > ndr_get_array_size(ndr, &r->portname)) {
6768                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->portname), ndr_get_array_length(ndr, &r->portname));
6769                         }
6770                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t)));
6771                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, ndr_get_array_length(ndr, &r->portname), sizeof(uint16_t), CH_UTF16));
6772                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_portname_0, 0);
6773                 }
6774         }
6775         return NDR_ERR_SUCCESS;
6776 }
6777
6778 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo5 *r)
6779 {
6780         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo5");
6781         ndr->depth++;
6782         ndr_print_ptr(ndr, "printername", r->printername);
6783         ndr->depth++;
6784         if (r->printername) {
6785                 ndr_print_string(ndr, "printername", r->printername);
6786         }
6787         ndr->depth--;
6788         ndr_print_ptr(ndr, "portname", r->portname);
6789         ndr->depth++;
6790         if (r->portname) {
6791                 ndr_print_string(ndr, "portname", r->portname);
6792         }
6793         ndr->depth--;
6794         ndr_print_spoolss_PrinterAttributes(ndr, "attributes", r->attributes);
6795         ndr_print_uint32(ndr, "device_not_selected_timeout", r->device_not_selected_timeout);
6796         ndr_print_uint32(ndr, "transmission_retry_timeout", r->transmission_retry_timeout);
6797         ndr->depth--;
6798 }
6799
6800 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo6 *r)
6801 {
6802         if (ndr_flags & NDR_SCALARS) {
6803                 NDR_CHECK(ndr_push_align(ndr, 4));
6804                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
6805         }
6806         if (ndr_flags & NDR_BUFFERS) {
6807         }
6808         return NDR_ERR_SUCCESS;
6809 }
6810
6811 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo6 *r)
6812 {
6813         if (ndr_flags & NDR_SCALARS) {
6814                 NDR_CHECK(ndr_pull_align(ndr, 4));
6815                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
6816         }
6817         if (ndr_flags & NDR_BUFFERS) {
6818         }
6819         return NDR_ERR_SUCCESS;
6820 }
6821
6822 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo6 *r)
6823 {
6824         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo6");
6825         ndr->depth++;
6826         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
6827         ndr->depth--;
6828 }
6829
6830 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo7(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfo7 *r)
6831 {
6832         if (ndr_flags & NDR_SCALARS) {
6833                 NDR_CHECK(ndr_push_align(ndr, 4));
6834                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->guid));
6835                 NDR_CHECK(ndr_push_spoolss_DsPrintAction(ndr, NDR_SCALARS, r->action));
6836         }
6837         if (ndr_flags & NDR_BUFFERS) {
6838                 if (r->guid) {
6839                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6840                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
6841                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->guid, CH_UTF16)));
6842                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->guid, ndr_charset_length(r->guid, CH_UTF16), sizeof(uint16_t), CH_UTF16));
6843                 }
6844         }
6845         return NDR_ERR_SUCCESS;
6846 }
6847
6848 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo7(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfo7 *r)
6849 {
6850         uint32_t _ptr_guid;
6851         TALLOC_CTX *_mem_save_guid_0;
6852         if (ndr_flags & NDR_SCALARS) {
6853                 NDR_CHECK(ndr_pull_align(ndr, 4));
6854                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_guid));
6855                 if (_ptr_guid) {
6856                         NDR_PULL_ALLOC(ndr, r->guid);
6857                 } else {
6858                         r->guid = NULL;
6859                 }
6860                 NDR_CHECK(ndr_pull_spoolss_DsPrintAction(ndr, NDR_SCALARS, &r->action));
6861         }
6862         if (ndr_flags & NDR_BUFFERS) {
6863                 if (r->guid) {
6864                         _mem_save_guid_0 = NDR_PULL_GET_MEM_CTX(ndr);
6865                         NDR_PULL_SET_MEM_CTX(ndr, r->guid, 0);
6866                         NDR_CHECK(ndr_pull_array_size(ndr, &r->guid));
6867                         NDR_CHECK(ndr_pull_array_length(ndr, &r->guid));
6868                         if (ndr_get_array_length(ndr, &r->guid) > ndr_get_array_size(ndr, &r->guid)) {
6869                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->guid), ndr_get_array_length(ndr, &r->guid));
6870                         }
6871                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t)));
6872                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->guid, ndr_get_array_length(ndr, &r->guid), sizeof(uint16_t), CH_UTF16));
6873                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_guid_0, 0);
6874                 }
6875         }
6876         return NDR_ERR_SUCCESS;
6877 }
6878
6879 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo7(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfo7 *r)
6880 {
6881         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfo7");
6882         ndr->depth++;
6883         ndr_print_ptr(ndr, "guid", r->guid);
6884         ndr->depth++;
6885         if (r->guid) {
6886                 ndr_print_string(ndr, "guid", r->guid);
6887         }
6888         ndr->depth--;
6889         ndr_print_spoolss_DsPrintAction(ndr, "action", r->action);
6890         ndr->depth--;
6891 }
6892
6893 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_SetPrinterInfo *r)
6894 {
6895         if (ndr_flags & NDR_SCALARS) {
6896                 int level = ndr_push_get_switch_value(ndr, r);
6897                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
6898                 switch (level) {
6899                         case 0: {
6900                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
6901                         break; }
6902
6903                         case 1: {
6904                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
6905                         break; }
6906
6907                         case 2: {
6908                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
6909                         break; }
6910
6911                         case 3: {
6912                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
6913                         break; }
6914
6915                         case 4: {
6916                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
6917                         break; }
6918
6919                         case 5: {
6920                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info5));
6921                         break; }
6922
6923                         case 6: {
6924                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
6925                         break; }
6926
6927                         case 7: {
6928                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info7));
6929                         break; }
6930
6931                         case 8: {
6932                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
6933                         break; }
6934
6935                         case 9: {
6936                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info9));
6937                         break; }
6938
6939                         default: {
6940                         break; }
6941
6942                 }
6943         }
6944         if (ndr_flags & NDR_BUFFERS) {
6945                 int level = ndr_push_get_switch_value(ndr, r);
6946                 switch (level) {
6947                         case 0:
6948                                 if (r->info0) {
6949                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
6950                                 }
6951                         break;
6952
6953                         case 1:
6954                                 if (r->info1) {
6955                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
6956                                 }
6957                         break;
6958
6959                         case 2:
6960                                 if (r->info2) {
6961                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
6962                                 }
6963                         break;
6964
6965                         case 3:
6966                                 if (r->info3) {
6967                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
6968                                 }
6969                         break;
6970
6971                         case 4:
6972                                 if (r->info4) {
6973                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
6974                                 }
6975                         break;
6976
6977                         case 5:
6978                                 if (r->info5) {
6979                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
6980                                 }
6981                         break;
6982
6983                         case 6:
6984                                 if (r->info6) {
6985                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
6986                                 }
6987                         break;
6988
6989                         case 7:
6990                                 if (r->info7) {
6991                                         NDR_CHECK(ndr_push_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
6992                                 }
6993                         break;
6994
6995                         case 8:
6996                                 if (r->info8) {
6997                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
6998                                 }
6999                         break;
7000
7001                         case 9:
7002                                 if (r->info9) {
7003                                         NDR_CHECK(ndr_push_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7004                                 }
7005                         break;
7006
7007                         default:
7008                         break;
7009
7010                 }
7011         }
7012         return NDR_ERR_SUCCESS;
7013 }
7014
7015 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_SetPrinterInfo *r)
7016 {
7017         int level;
7018         uint32_t _level;
7019         TALLOC_CTX *_mem_save_info0_0;
7020         TALLOC_CTX *_mem_save_info1_0;
7021         TALLOC_CTX *_mem_save_info2_0;
7022         TALLOC_CTX *_mem_save_info3_0;
7023         TALLOC_CTX *_mem_save_info4_0;
7024         TALLOC_CTX *_mem_save_info5_0;
7025         TALLOC_CTX *_mem_save_info6_0;
7026         TALLOC_CTX *_mem_save_info7_0;
7027         TALLOC_CTX *_mem_save_info8_0;
7028         TALLOC_CTX *_mem_save_info9_0;
7029         level = ndr_pull_get_switch_value(ndr, r);
7030         if (ndr_flags & NDR_SCALARS) {
7031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
7032                 if (_level != level) {
7033                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
7034                 }
7035                 switch (level) {
7036                         case 0: {
7037                                 uint32_t _ptr_info0;
7038                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
7039                                 if (_ptr_info0) {
7040                                         NDR_PULL_ALLOC(ndr, r->info0);
7041                                 } else {
7042                                         r->info0 = NULL;
7043                                 }
7044                         break; }
7045
7046                         case 1: {
7047                                 uint32_t _ptr_info1;
7048                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
7049                                 if (_ptr_info1) {
7050                                         NDR_PULL_ALLOC(ndr, r->info1);
7051                                 } else {
7052                                         r->info1 = NULL;
7053                                 }
7054                         break; }
7055
7056                         case 2: {
7057                                 uint32_t _ptr_info2;
7058                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
7059                                 if (_ptr_info2) {
7060                                         NDR_PULL_ALLOC(ndr, r->info2);
7061                                 } else {
7062                                         r->info2 = NULL;
7063                                 }
7064                         break; }
7065
7066                         case 3: {
7067                                 uint32_t _ptr_info3;
7068                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
7069                                 if (_ptr_info3) {
7070                                         NDR_PULL_ALLOC(ndr, r->info3);
7071                                 } else {
7072                                         r->info3 = NULL;
7073                                 }
7074                         break; }
7075
7076                         case 4: {
7077                                 uint32_t _ptr_info4;
7078                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
7079                                 if (_ptr_info4) {
7080                                         NDR_PULL_ALLOC(ndr, r->info4);
7081                                 } else {
7082                                         r->info4 = NULL;
7083                                 }
7084                         break; }
7085
7086                         case 5: {
7087                                 uint32_t _ptr_info5;
7088                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info5));
7089                                 if (_ptr_info5) {
7090                                         NDR_PULL_ALLOC(ndr, r->info5);
7091                                 } else {
7092                                         r->info5 = NULL;
7093                                 }
7094                         break; }
7095
7096                         case 6: {
7097                                 uint32_t _ptr_info6;
7098                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
7099                                 if (_ptr_info6) {
7100                                         NDR_PULL_ALLOC(ndr, r->info6);
7101                                 } else {
7102                                         r->info6 = NULL;
7103                                 }
7104                         break; }
7105
7106                         case 7: {
7107                                 uint32_t _ptr_info7;
7108                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info7));
7109                                 if (_ptr_info7) {
7110                                         NDR_PULL_ALLOC(ndr, r->info7);
7111                                 } else {
7112                                         r->info7 = NULL;
7113                                 }
7114                         break; }
7115
7116                         case 8: {
7117                                 uint32_t _ptr_info8;
7118                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
7119                                 if (_ptr_info8) {
7120                                         NDR_PULL_ALLOC(ndr, r->info8);
7121                                 } else {
7122                                         r->info8 = NULL;
7123                                 }
7124                         break; }
7125
7126                         case 9: {
7127                                 uint32_t _ptr_info9;
7128                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info9));
7129                                 if (_ptr_info9) {
7130                                         NDR_PULL_ALLOC(ndr, r->info9);
7131                                 } else {
7132                                         r->info9 = NULL;
7133                                 }
7134                         break; }
7135
7136                         default: {
7137                         break; }
7138
7139                 }
7140         }
7141         if (ndr_flags & NDR_BUFFERS) {
7142                 switch (level) {
7143                         case 0:
7144                                 if (r->info0) {
7145                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
7146                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
7147                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo0(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
7148                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
7149                                 }
7150                         break;
7151
7152                         case 1:
7153                                 if (r->info1) {
7154                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
7155                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
7156                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
7157                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
7158                                 }
7159                         break;
7160
7161                         case 2:
7162                                 if (r->info2) {
7163                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
7164                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
7165                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
7166                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
7167                                 }
7168                         break;
7169
7170                         case 3:
7171                                 if (r->info3) {
7172                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
7173                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
7174                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo3(ndr, NDR_SCALARS, r->info3));
7175                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
7176                                 }
7177                         break;
7178
7179                         case 4:
7180                                 if (r->info4) {
7181                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
7182                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
7183                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
7184                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
7185                                 }
7186                         break;
7187
7188                         case 5:
7189                                 if (r->info5) {
7190                                         _mem_save_info5_0 = NDR_PULL_GET_MEM_CTX(ndr);
7191                                         NDR_PULL_SET_MEM_CTX(ndr, r->info5, 0);
7192                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo5(ndr, NDR_SCALARS|NDR_BUFFERS, r->info5));
7193                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info5_0, 0);
7194                                 }
7195                         break;
7196
7197                         case 6:
7198                                 if (r->info6) {
7199                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
7200                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
7201                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo6(ndr, NDR_SCALARS, r->info6));
7202                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
7203                                 }
7204                         break;
7205
7206                         case 7:
7207                                 if (r->info7) {
7208                                         _mem_save_info7_0 = NDR_PULL_GET_MEM_CTX(ndr);
7209                                         NDR_PULL_SET_MEM_CTX(ndr, r->info7, 0);
7210                                         NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo7(ndr, NDR_SCALARS|NDR_BUFFERS, r->info7));
7211                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info7_0, 0);
7212                                 }
7213                         break;
7214
7215                         case 8:
7216                                 if (r->info8) {
7217                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
7218                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
7219                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
7220                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
7221                                 }
7222                         break;
7223
7224                         case 9:
7225                                 if (r->info9) {
7226                                         _mem_save_info9_0 = NDR_PULL_GET_MEM_CTX(ndr);
7227                                         NDR_PULL_SET_MEM_CTX(ndr, r->info9, 0);
7228                                         NDR_CHECK(ndr_pull_spoolss_DeviceModeInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info9));
7229                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info9_0, 0);
7230                                 }
7231                         break;
7232
7233                         default:
7234                         break;
7235
7236                 }
7237         }
7238         return NDR_ERR_SUCCESS;
7239 }
7240
7241 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_SetPrinterInfo *r)
7242 {
7243         int level;
7244         level = ndr_print_get_switch_value(ndr, r);
7245         ndr_print_union(ndr, name, level, "spoolss_SetPrinterInfo");
7246         switch (level) {
7247                 case 0:
7248                         ndr_print_ptr(ndr, "info0", r->info0);
7249                         ndr->depth++;
7250                         if (r->info0) {
7251                                 ndr_print_spoolss_SetPrinterInfo0(ndr, "info0", r->info0);
7252                         }
7253                         ndr->depth--;
7254                 break;
7255
7256                 case 1:
7257                         ndr_print_ptr(ndr, "info1", r->info1);
7258                         ndr->depth++;
7259                         if (r->info1) {
7260                                 ndr_print_spoolss_SetPrinterInfo1(ndr, "info1", r->info1);
7261                         }
7262                         ndr->depth--;
7263                 break;
7264
7265                 case 2:
7266                         ndr_print_ptr(ndr, "info2", r->info2);
7267                         ndr->depth++;
7268                         if (r->info2) {
7269                                 ndr_print_spoolss_SetPrinterInfo2(ndr, "info2", r->info2);
7270                         }
7271                         ndr->depth--;
7272                 break;
7273
7274                 case 3:
7275                         ndr_print_ptr(ndr, "info3", r->info3);
7276                         ndr->depth++;
7277                         if (r->info3) {
7278                                 ndr_print_spoolss_SetPrinterInfo3(ndr, "info3", r->info3);
7279                         }
7280                         ndr->depth--;
7281                 break;
7282
7283                 case 4:
7284                         ndr_print_ptr(ndr, "info4", r->info4);
7285                         ndr->depth++;
7286                         if (r->info4) {
7287                                 ndr_print_spoolss_SetPrinterInfo4(ndr, "info4", r->info4);
7288                         }
7289                         ndr->depth--;
7290                 break;
7291
7292                 case 5:
7293                         ndr_print_ptr(ndr, "info5", r->info5);
7294                         ndr->depth++;
7295                         if (r->info5) {
7296                                 ndr_print_spoolss_SetPrinterInfo5(ndr, "info5", r->info5);
7297                         }
7298                         ndr->depth--;
7299                 break;
7300
7301                 case 6:
7302                         ndr_print_ptr(ndr, "info6", r->info6);
7303                         ndr->depth++;
7304                         if (r->info6) {
7305                                 ndr_print_spoolss_SetPrinterInfo6(ndr, "info6", r->info6);
7306                         }
7307                         ndr->depth--;
7308                 break;
7309
7310                 case 7:
7311                         ndr_print_ptr(ndr, "info7", r->info7);
7312                         ndr->depth++;
7313                         if (r->info7) {
7314                                 ndr_print_spoolss_SetPrinterInfo7(ndr, "info7", r->info7);
7315                         }
7316                         ndr->depth--;
7317                 break;
7318
7319                 case 8:
7320                         ndr_print_ptr(ndr, "info8", r->info8);
7321                         ndr->depth++;
7322                         if (r->info8) {
7323                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info8", r->info8);
7324                         }
7325                         ndr->depth--;
7326                 break;
7327
7328                 case 9:
7329                         ndr_print_ptr(ndr, "info9", r->info9);
7330                         ndr->depth++;
7331                         if (r->info9) {
7332                                 ndr_print_spoolss_DeviceModeInfo(ndr, "info9", r->info9);
7333                         }
7334                         ndr->depth--;
7335                 break;
7336
7337                 default:
7338                 break;
7339
7340         }
7341 }
7342
7343 static enum ndr_err_code ndr_push_spoolss_SetPrinterInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_SetPrinterInfoCtr *r)
7344 {
7345         if (ndr_flags & NDR_SCALARS) {
7346                 NDR_CHECK(ndr_push_align(ndr, 4));
7347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
7348                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
7349                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7350         }
7351         if (ndr_flags & NDR_BUFFERS) {
7352                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7353         }
7354         return NDR_ERR_SUCCESS;
7355 }
7356
7357 static enum ndr_err_code ndr_pull_spoolss_SetPrinterInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_SetPrinterInfoCtr *r)
7358 {
7359         if (ndr_flags & NDR_SCALARS) {
7360                 NDR_CHECK(ndr_pull_align(ndr, 4));
7361                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
7362                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
7363                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_SCALARS, &r->info));
7364         }
7365         if (ndr_flags & NDR_BUFFERS) {
7366                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfo(ndr, NDR_BUFFERS, &r->info));
7367         }
7368         return NDR_ERR_SUCCESS;
7369 }
7370
7371 _PUBLIC_ void ndr_print_spoolss_SetPrinterInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_SetPrinterInfoCtr *r)
7372 {
7373         ndr_print_struct(ndr, name, "spoolss_SetPrinterInfoCtr");
7374         ndr->depth++;
7375         ndr_print_uint32(ndr, "level", r->level);
7376         ndr_print_set_switch_value(ndr, &r->info, r->level);
7377         ndr_print_spoolss_SetPrinterInfo(ndr, "info", &r->info);
7378         ndr->depth--;
7379 }
7380
7381 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_StringArray(struct ndr_push *ndr, int ndr_flags, const struct spoolss_StringArray *r)
7382 {
7383         if (ndr_flags & NDR_SCALARS) {
7384                 NDR_CHECK(ndr_push_align(ndr, 4));
7385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, (ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2));
7386                 {
7387                         uint32_t _flags_save_string_array = ndr->flags;
7388                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7389                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string));
7390                         ndr->flags = _flags_save_string_array;
7391                 }
7392         }
7393         if (ndr_flags & NDR_BUFFERS) {
7394         }
7395         return NDR_ERR_SUCCESS;
7396 }
7397
7398 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_StringArray(struct ndr_pull *ndr, int ndr_flags, struct spoolss_StringArray *r)
7399 {
7400         if (ndr_flags & NDR_SCALARS) {
7401                 NDR_CHECK(ndr_pull_align(ndr, 4));
7402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
7403                 {
7404                         uint32_t _flags_save_string_array = ndr->flags;
7405                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
7406                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string));
7407                         ndr->flags = _flags_save_string_array;
7408                 }
7409         }
7410         if (ndr_flags & NDR_BUFFERS) {
7411         }
7412         return NDR_ERR_SUCCESS;
7413 }
7414
7415 _PUBLIC_ void ndr_print_spoolss_StringArray(struct ndr_print *ndr, const char *name, const struct spoolss_StringArray *r)
7416 {
7417         ndr_print_struct(ndr, name, "spoolss_StringArray");
7418         ndr->depth++;
7419         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?(ndr_size_spoolss_StringArray(r, ndr->iconv_convenience, ndr->flags) - 4) / 2:r->_ndr_size);
7420         ndr_print_string_array(ndr, "string", r->string);
7421         ndr->depth--;
7422 }
7423
7424 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo1 *r)
7425 {
7426         if (ndr_flags & NDR_SCALARS) {
7427                 NDR_CHECK(ndr_push_align(ndr, 4));
7428                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7429         }
7430         if (ndr_flags & NDR_BUFFERS) {
7431                 if (r->driver_name) {
7432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7434                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7435                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7436                 }
7437         }
7438         return NDR_ERR_SUCCESS;
7439 }
7440
7441 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo1 *r)
7442 {
7443         uint32_t _ptr_driver_name;
7444         TALLOC_CTX *_mem_save_driver_name_0;
7445         if (ndr_flags & NDR_SCALARS) {
7446                 NDR_CHECK(ndr_pull_align(ndr, 4));
7447                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7448                 if (_ptr_driver_name) {
7449                         NDR_PULL_ALLOC(ndr, r->driver_name);
7450                 } else {
7451                         r->driver_name = NULL;
7452                 }
7453         }
7454         if (ndr_flags & NDR_BUFFERS) {
7455                 if (r->driver_name) {
7456                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7457                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7458                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7459                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7460                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7461                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7462                         }
7463                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7464                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7465                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7466                 }
7467         }
7468         return NDR_ERR_SUCCESS;
7469 }
7470
7471 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo1 *r)
7472 {
7473         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo1");
7474         ndr->depth++;
7475         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7476         ndr->depth++;
7477         if (r->driver_name) {
7478                 ndr_print_string(ndr, "driver_name", r->driver_name);
7479         }
7480         ndr->depth--;
7481         ndr->depth--;
7482 }
7483
7484 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverOSVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverOSVersion r)
7485 {
7486         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
7487         return NDR_ERR_SUCCESS;
7488 }
7489
7490 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverOSVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverOSVersion *r)
7491 {
7492         uint32_t v;
7493         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
7494         *r = v;
7495         return NDR_ERR_SUCCESS;
7496 }
7497
7498 _PUBLIC_ void ndr_print_spoolss_DriverOSVersion(struct ndr_print *ndr, const char *name, enum spoolss_DriverOSVersion r)
7499 {
7500         const char *val = NULL;
7501
7502         switch (r) {
7503                 case SPOOLSS_DRIVER_VERSION_9X: val = "SPOOLSS_DRIVER_VERSION_9X"; break;
7504                 case SPOOLSS_DRIVER_VERSION_NT35: val = "SPOOLSS_DRIVER_VERSION_NT35"; break;
7505                 case SPOOLSS_DRIVER_VERSION_NT4: val = "SPOOLSS_DRIVER_VERSION_NT4"; break;
7506                 case SPOOLSS_DRIVER_VERSION_200X: val = "SPOOLSS_DRIVER_VERSION_200X"; break;
7507         }
7508         ndr_print_enum(ndr, name, "ENUM", val, r);
7509 }
7510
7511 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo2 *r)
7512 {
7513         if (ndr_flags & NDR_SCALARS) {
7514                 NDR_CHECK(ndr_push_align(ndr, 4));
7515                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7517                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7518                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7519                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7520                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7521         }
7522         if (ndr_flags & NDR_BUFFERS) {
7523                 if (r->driver_name) {
7524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7526                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7527                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7528                 }
7529                 if (r->architecture) {
7530                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7533                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7534                 }
7535                 if (r->driver_path) {
7536                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7537                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7538                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7539                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7540                 }
7541                 if (r->data_file) {
7542                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7543                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7544                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7545                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7546                 }
7547                 if (r->config_file) {
7548                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7549                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7550                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7551                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7552                 }
7553         }
7554         return NDR_ERR_SUCCESS;
7555 }
7556
7557 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo2 *r)
7558 {
7559         uint32_t _ptr_driver_name;
7560         TALLOC_CTX *_mem_save_driver_name_0;
7561         uint32_t _ptr_architecture;
7562         TALLOC_CTX *_mem_save_architecture_0;
7563         uint32_t _ptr_driver_path;
7564         TALLOC_CTX *_mem_save_driver_path_0;
7565         uint32_t _ptr_data_file;
7566         TALLOC_CTX *_mem_save_data_file_0;
7567         uint32_t _ptr_config_file;
7568         TALLOC_CTX *_mem_save_config_file_0;
7569         if (ndr_flags & NDR_SCALARS) {
7570                 NDR_CHECK(ndr_pull_align(ndr, 4));
7571                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7573                 if (_ptr_driver_name) {
7574                         NDR_PULL_ALLOC(ndr, r->driver_name);
7575                 } else {
7576                         r->driver_name = NULL;
7577                 }
7578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7579                 if (_ptr_architecture) {
7580                         NDR_PULL_ALLOC(ndr, r->architecture);
7581                 } else {
7582                         r->architecture = NULL;
7583                 }
7584                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7585                 if (_ptr_driver_path) {
7586                         NDR_PULL_ALLOC(ndr, r->driver_path);
7587                 } else {
7588                         r->driver_path = NULL;
7589                 }
7590                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7591                 if (_ptr_data_file) {
7592                         NDR_PULL_ALLOC(ndr, r->data_file);
7593                 } else {
7594                         r->data_file = NULL;
7595                 }
7596                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7597                 if (_ptr_config_file) {
7598                         NDR_PULL_ALLOC(ndr, r->config_file);
7599                 } else {
7600                         r->config_file = NULL;
7601                 }
7602         }
7603         if (ndr_flags & NDR_BUFFERS) {
7604                 if (r->driver_name) {
7605                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7606                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7607                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7608                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7609                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7610                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7611                         }
7612                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7613                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7614                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7615                 }
7616                 if (r->architecture) {
7617                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7618                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7619                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7620                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7621                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7622                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7623                         }
7624                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7625                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7626                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7627                 }
7628                 if (r->driver_path) {
7629                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7630                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7631                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7632                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7633                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7634                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7635                         }
7636                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7637                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7638                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7639                 }
7640                 if (r->data_file) {
7641                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7642                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7643                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7644                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7645                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7646                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7647                         }
7648                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7649                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7650                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7651                 }
7652                 if (r->config_file) {
7653                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7654                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7655                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7656                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7657                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7658                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7659                         }
7660                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7661                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7662                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7663                 }
7664         }
7665         return NDR_ERR_SUCCESS;
7666 }
7667
7668 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo2 *r)
7669 {
7670         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo2");
7671         ndr->depth++;
7672         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7673         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7674         ndr->depth++;
7675         if (r->driver_name) {
7676                 ndr_print_string(ndr, "driver_name", r->driver_name);
7677         }
7678         ndr->depth--;
7679         ndr_print_ptr(ndr, "architecture", r->architecture);
7680         ndr->depth++;
7681         if (r->architecture) {
7682                 ndr_print_string(ndr, "architecture", r->architecture);
7683         }
7684         ndr->depth--;
7685         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7686         ndr->depth++;
7687         if (r->driver_path) {
7688                 ndr_print_string(ndr, "driver_path", r->driver_path);
7689         }
7690         ndr->depth--;
7691         ndr_print_ptr(ndr, "data_file", r->data_file);
7692         ndr->depth++;
7693         if (r->data_file) {
7694                 ndr_print_string(ndr, "data_file", r->data_file);
7695         }
7696         ndr->depth--;
7697         ndr_print_ptr(ndr, "config_file", r->config_file);
7698         ndr->depth++;
7699         if (r->config_file) {
7700                 ndr_print_string(ndr, "config_file", r->config_file);
7701         }
7702         ndr->depth--;
7703         ndr->depth--;
7704 }
7705
7706 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo3 *r)
7707 {
7708         if (ndr_flags & NDR_SCALARS) {
7709                 NDR_CHECK(ndr_push_align(ndr, 4));
7710                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
7711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
7712                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
7713                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
7714                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
7715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
7716                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
7717                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
7718                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
7719                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
7720                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
7721         }
7722         if (ndr_flags & NDR_BUFFERS) {
7723                 if (r->driver_name) {
7724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
7727                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7728                 }
7729                 if (r->architecture) {
7730                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7731                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7732                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
7733                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7734                 }
7735                 if (r->driver_path) {
7736                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7737                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7738                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
7739                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7740                 }
7741                 if (r->data_file) {
7742                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7743                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7744                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
7745                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7746                 }
7747                 if (r->config_file) {
7748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7750                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
7751                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7752                 }
7753                 if (r->help_file) {
7754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
7757                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7758                 }
7759                 if (r->monitor_name) {
7760                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7761                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
7763                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7764                 }
7765                 if (r->default_datatype) {
7766                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7767                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
7768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
7769                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
7770                 }
7771                 if (r->dependent_files) {
7772                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7773                 }
7774         }
7775         return NDR_ERR_SUCCESS;
7776 }
7777
7778 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo3 *r)
7779 {
7780         uint32_t _ptr_driver_name;
7781         TALLOC_CTX *_mem_save_driver_name_0;
7782         uint32_t _ptr_architecture;
7783         TALLOC_CTX *_mem_save_architecture_0;
7784         uint32_t _ptr_driver_path;
7785         TALLOC_CTX *_mem_save_driver_path_0;
7786         uint32_t _ptr_data_file;
7787         TALLOC_CTX *_mem_save_data_file_0;
7788         uint32_t _ptr_config_file;
7789         TALLOC_CTX *_mem_save_config_file_0;
7790         uint32_t _ptr_help_file;
7791         TALLOC_CTX *_mem_save_help_file_0;
7792         uint32_t _ptr_monitor_name;
7793         TALLOC_CTX *_mem_save_monitor_name_0;
7794         uint32_t _ptr_default_datatype;
7795         TALLOC_CTX *_mem_save_default_datatype_0;
7796         uint32_t _ptr_dependent_files;
7797         TALLOC_CTX *_mem_save_dependent_files_0;
7798         if (ndr_flags & NDR_SCALARS) {
7799                 NDR_CHECK(ndr_pull_align(ndr, 4));
7800                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
7801                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
7802                 if (_ptr_driver_name) {
7803                         NDR_PULL_ALLOC(ndr, r->driver_name);
7804                 } else {
7805                         r->driver_name = NULL;
7806                 }
7807                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
7808                 if (_ptr_architecture) {
7809                         NDR_PULL_ALLOC(ndr, r->architecture);
7810                 } else {
7811                         r->architecture = NULL;
7812                 }
7813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
7814                 if (_ptr_driver_path) {
7815                         NDR_PULL_ALLOC(ndr, r->driver_path);
7816                 } else {
7817                         r->driver_path = NULL;
7818                 }
7819                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
7820                 if (_ptr_data_file) {
7821                         NDR_PULL_ALLOC(ndr, r->data_file);
7822                 } else {
7823                         r->data_file = NULL;
7824                 }
7825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
7826                 if (_ptr_config_file) {
7827                         NDR_PULL_ALLOC(ndr, r->config_file);
7828                 } else {
7829                         r->config_file = NULL;
7830                 }
7831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
7832                 if (_ptr_help_file) {
7833                         NDR_PULL_ALLOC(ndr, r->help_file);
7834                 } else {
7835                         r->help_file = NULL;
7836                 }
7837                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
7838                 if (_ptr_monitor_name) {
7839                         NDR_PULL_ALLOC(ndr, r->monitor_name);
7840                 } else {
7841                         r->monitor_name = NULL;
7842                 }
7843                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
7844                 if (_ptr_default_datatype) {
7845                         NDR_PULL_ALLOC(ndr, r->default_datatype);
7846                 } else {
7847                         r->default_datatype = NULL;
7848                 }
7849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
7850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
7851                 if (_ptr_dependent_files) {
7852                         NDR_PULL_ALLOC(ndr, r->dependent_files);
7853                 } else {
7854                         r->dependent_files = NULL;
7855                 }
7856         }
7857         if (ndr_flags & NDR_BUFFERS) {
7858                 if (r->driver_name) {
7859                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7860                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
7861                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
7862                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
7863                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
7864                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
7865                         }
7866                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
7867                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
7868                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
7869                 }
7870                 if (r->architecture) {
7871                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
7872                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
7873                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
7874                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
7875                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
7876                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
7877                         }
7878                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
7879                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
7880                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
7881                 }
7882                 if (r->driver_path) {
7883                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
7884                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
7885                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
7886                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
7887                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
7888                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
7889                         }
7890                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
7891                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
7892                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
7893                 }
7894                 if (r->data_file) {
7895                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7896                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
7897                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
7898                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
7899                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
7900                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
7901                         }
7902                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
7903                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
7904                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
7905                 }
7906                 if (r->config_file) {
7907                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7908                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
7909                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
7910                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
7911                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
7912                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
7913                         }
7914                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
7915                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
7916                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
7917                 }
7918                 if (r->help_file) {
7919                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
7920                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
7921                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
7922                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
7923                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
7924                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
7925                         }
7926                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
7927                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
7928                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
7929                 }
7930                 if (r->monitor_name) {
7931                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
7932                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
7933                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
7934                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
7935                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
7936                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
7937                         }
7938                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
7939                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
7940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
7941                 }
7942                 if (r->default_datatype) {
7943                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
7944                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
7945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
7946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
7947                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
7948                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
7949                         }
7950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
7951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
7952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
7953                 }
7954                 if (r->dependent_files) {
7955                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
7956                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
7957                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
7958                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
7959                 }
7960         }
7961         return NDR_ERR_SUCCESS;
7962 }
7963
7964 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo3 *r)
7965 {
7966         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo3");
7967         ndr->depth++;
7968         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
7969         ndr_print_ptr(ndr, "driver_name", r->driver_name);
7970         ndr->depth++;
7971         if (r->driver_name) {
7972                 ndr_print_string(ndr, "driver_name", r->driver_name);
7973         }
7974         ndr->depth--;
7975         ndr_print_ptr(ndr, "architecture", r->architecture);
7976         ndr->depth++;
7977         if (r->architecture) {
7978                 ndr_print_string(ndr, "architecture", r->architecture);
7979         }
7980         ndr->depth--;
7981         ndr_print_ptr(ndr, "driver_path", r->driver_path);
7982         ndr->depth++;
7983         if (r->driver_path) {
7984                 ndr_print_string(ndr, "driver_path", r->driver_path);
7985         }
7986         ndr->depth--;
7987         ndr_print_ptr(ndr, "data_file", r->data_file);
7988         ndr->depth++;
7989         if (r->data_file) {
7990                 ndr_print_string(ndr, "data_file", r->data_file);
7991         }
7992         ndr->depth--;
7993         ndr_print_ptr(ndr, "config_file", r->config_file);
7994         ndr->depth++;
7995         if (r->config_file) {
7996                 ndr_print_string(ndr, "config_file", r->config_file);
7997         }
7998         ndr->depth--;
7999         ndr_print_ptr(ndr, "help_file", r->help_file);
8000         ndr->depth++;
8001         if (r->help_file) {
8002                 ndr_print_string(ndr, "help_file", r->help_file);
8003         }
8004         ndr->depth--;
8005         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8006         ndr->depth++;
8007         if (r->monitor_name) {
8008                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8009         }
8010         ndr->depth--;
8011         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8012         ndr->depth++;
8013         if (r->default_datatype) {
8014                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8015         }
8016         ndr->depth--;
8017         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8018         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8019         ndr->depth++;
8020         if (r->dependent_files) {
8021                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8022         }
8023         ndr->depth--;
8024         ndr->depth--;
8025 }
8026
8027 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo4 *r)
8028 {
8029         if (ndr_flags & NDR_SCALARS) {
8030                 NDR_CHECK(ndr_push_align(ndr, 4));
8031                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8032                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8033                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8034                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8035                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8038                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8039                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8040                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8041                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8044         }
8045         if (ndr_flags & NDR_BUFFERS) {
8046                 if (r->driver_name) {
8047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8049                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8050                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8051                 }
8052                 if (r->architecture) {
8053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8057                 }
8058                 if (r->driver_path) {
8059                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8060                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8061                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8062                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8063                 }
8064                 if (r->data_file) {
8065                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8066                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8067                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8068                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8069                 }
8070                 if (r->config_file) {
8071                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8072                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8073                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8074                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8075                 }
8076                 if (r->help_file) {
8077                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8078                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8079                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8080                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8081                 }
8082                 if (r->monitor_name) {
8083                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8084                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8085                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8086                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8087                 }
8088                 if (r->default_datatype) {
8089                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8090                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8091                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8092                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8093                 }
8094                 if (r->dependent_files) {
8095                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8096                 }
8097                 if (r->previous_names) {
8098                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8099                 }
8100         }
8101         return NDR_ERR_SUCCESS;
8102 }
8103
8104 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo4 *r)
8105 {
8106         uint32_t _ptr_driver_name;
8107         TALLOC_CTX *_mem_save_driver_name_0;
8108         uint32_t _ptr_architecture;
8109         TALLOC_CTX *_mem_save_architecture_0;
8110         uint32_t _ptr_driver_path;
8111         TALLOC_CTX *_mem_save_driver_path_0;
8112         uint32_t _ptr_data_file;
8113         TALLOC_CTX *_mem_save_data_file_0;
8114         uint32_t _ptr_config_file;
8115         TALLOC_CTX *_mem_save_config_file_0;
8116         uint32_t _ptr_help_file;
8117         TALLOC_CTX *_mem_save_help_file_0;
8118         uint32_t _ptr_monitor_name;
8119         TALLOC_CTX *_mem_save_monitor_name_0;
8120         uint32_t _ptr_default_datatype;
8121         TALLOC_CTX *_mem_save_default_datatype_0;
8122         uint32_t _ptr_dependent_files;
8123         TALLOC_CTX *_mem_save_dependent_files_0;
8124         uint32_t _ptr_previous_names;
8125         TALLOC_CTX *_mem_save_previous_names_0;
8126         if (ndr_flags & NDR_SCALARS) {
8127                 NDR_CHECK(ndr_pull_align(ndr, 4));
8128                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8129                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8130                 if (_ptr_driver_name) {
8131                         NDR_PULL_ALLOC(ndr, r->driver_name);
8132                 } else {
8133                         r->driver_name = NULL;
8134                 }
8135                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8136                 if (_ptr_architecture) {
8137                         NDR_PULL_ALLOC(ndr, r->architecture);
8138                 } else {
8139                         r->architecture = NULL;
8140                 }
8141                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8142                 if (_ptr_driver_path) {
8143                         NDR_PULL_ALLOC(ndr, r->driver_path);
8144                 } else {
8145                         r->driver_path = NULL;
8146                 }
8147                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8148                 if (_ptr_data_file) {
8149                         NDR_PULL_ALLOC(ndr, r->data_file);
8150                 } else {
8151                         r->data_file = NULL;
8152                 }
8153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8154                 if (_ptr_config_file) {
8155                         NDR_PULL_ALLOC(ndr, r->config_file);
8156                 } else {
8157                         r->config_file = NULL;
8158                 }
8159                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8160                 if (_ptr_help_file) {
8161                         NDR_PULL_ALLOC(ndr, r->help_file);
8162                 } else {
8163                         r->help_file = NULL;
8164                 }
8165                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8166                 if (_ptr_monitor_name) {
8167                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8168                 } else {
8169                         r->monitor_name = NULL;
8170                 }
8171                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8172                 if (_ptr_default_datatype) {
8173                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8174                 } else {
8175                         r->default_datatype = NULL;
8176                 }
8177                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8178                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8179                 if (_ptr_dependent_files) {
8180                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8181                 } else {
8182                         r->dependent_files = NULL;
8183                 }
8184                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8185                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8186                 if (_ptr_previous_names) {
8187                         NDR_PULL_ALLOC(ndr, r->previous_names);
8188                 } else {
8189                         r->previous_names = NULL;
8190                 }
8191         }
8192         if (ndr_flags & NDR_BUFFERS) {
8193                 if (r->driver_name) {
8194                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8195                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8196                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8197                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8198                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8199                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8200                         }
8201                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8202                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8203                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8204                 }
8205                 if (r->architecture) {
8206                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8207                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8208                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8209                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8210                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8211                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8212                         }
8213                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8214                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8215                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8216                 }
8217                 if (r->driver_path) {
8218                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8219                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8222                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8224                         }
8225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8228                 }
8229                 if (r->data_file) {
8230                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8231                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8234                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8235                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8236                         }
8237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8240                 }
8241                 if (r->config_file) {
8242                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8243                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8246                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8247                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8248                         }
8249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8252                 }
8253                 if (r->help_file) {
8254                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8255                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8256                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8257                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8258                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8259                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8260                         }
8261                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8262                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8263                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8264                 }
8265                 if (r->monitor_name) {
8266                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8267                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8268                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8269                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8270                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8271                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8272                         }
8273                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8274                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8276                 }
8277                 if (r->default_datatype) {
8278                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8279                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8280                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8281                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8282                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8283                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8284                         }
8285                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8286                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8287                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8288                 }
8289                 if (r->dependent_files) {
8290                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8291                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8292                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8293                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8294                 }
8295                 if (r->previous_names) {
8296                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8297                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8298                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8299                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8300                 }
8301         }
8302         return NDR_ERR_SUCCESS;
8303 }
8304
8305 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo4 *r)
8306 {
8307         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo4");
8308         ndr->depth++;
8309         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8310         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8311         ndr->depth++;
8312         if (r->driver_name) {
8313                 ndr_print_string(ndr, "driver_name", r->driver_name);
8314         }
8315         ndr->depth--;
8316         ndr_print_ptr(ndr, "architecture", r->architecture);
8317         ndr->depth++;
8318         if (r->architecture) {
8319                 ndr_print_string(ndr, "architecture", r->architecture);
8320         }
8321         ndr->depth--;
8322         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8323         ndr->depth++;
8324         if (r->driver_path) {
8325                 ndr_print_string(ndr, "driver_path", r->driver_path);
8326         }
8327         ndr->depth--;
8328         ndr_print_ptr(ndr, "data_file", r->data_file);
8329         ndr->depth++;
8330         if (r->data_file) {
8331                 ndr_print_string(ndr, "data_file", r->data_file);
8332         }
8333         ndr->depth--;
8334         ndr_print_ptr(ndr, "config_file", r->config_file);
8335         ndr->depth++;
8336         if (r->config_file) {
8337                 ndr_print_string(ndr, "config_file", r->config_file);
8338         }
8339         ndr->depth--;
8340         ndr_print_ptr(ndr, "help_file", r->help_file);
8341         ndr->depth++;
8342         if (r->help_file) {
8343                 ndr_print_string(ndr, "help_file", r->help_file);
8344         }
8345         ndr->depth--;
8346         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8347         ndr->depth++;
8348         if (r->monitor_name) {
8349                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8350         }
8351         ndr->depth--;
8352         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8353         ndr->depth++;
8354         if (r->default_datatype) {
8355                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8356         }
8357         ndr->depth--;
8358         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8359         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8360         ndr->depth++;
8361         if (r->dependent_files) {
8362                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8363         }
8364         ndr->depth--;
8365         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
8366         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8367         ndr->depth++;
8368         if (r->previous_names) {
8369                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8370         }
8371         ndr->depth--;
8372         ndr->depth--;
8373 }
8374
8375 static enum ndr_err_code ndr_push_spoolss_DriverAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
8376 {
8377         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
8378         return NDR_ERR_SUCCESS;
8379 }
8380
8381 static enum ndr_err_code ndr_pull_spoolss_DriverAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
8382 {
8383         uint32_t v;
8384         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
8385         *r = v;
8386         return NDR_ERR_SUCCESS;
8387 }
8388
8389 _PUBLIC_ void ndr_print_spoolss_DriverAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
8390 {
8391         ndr_print_uint32(ndr, name, r);
8392         ndr->depth++;
8393         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_DRIVER_PACKAGE_AWARE", PRINTER_DRIVER_PACKAGE_AWARE, r);
8394         ndr->depth--;
8395 }
8396
8397 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8398 {
8399         if (ndr_flags & NDR_SCALARS) {
8400                 NDR_CHECK(ndr_push_align(ndr, 8));
8401                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8402                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8404                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8405                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8406                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8408                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8409                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8411                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8413                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8414                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8415                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8416                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8417                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8419                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8420         }
8421         if (ndr_flags & NDR_BUFFERS) {
8422                 if (r->driver_name) {
8423                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8424                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8426                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8427                 }
8428                 if (r->architecture) {
8429                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8432                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8433                 }
8434                 if (r->driver_path) {
8435                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8438                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8439                 }
8440                 if (r->data_file) {
8441                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8444                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8445                 }
8446                 if (r->config_file) {
8447                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8450                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8451                 }
8452                 if (r->help_file) {
8453                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8454                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8456                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8457                 }
8458                 if (r->monitor_name) {
8459                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8460                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8462                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8463                 }
8464                 if (r->default_datatype) {
8465                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8466                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8468                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8469                 }
8470                 if (r->dependent_files) {
8471                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8472                 }
8473                 if (r->previous_names) {
8474                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8475                 }
8476                 if (r->manufacturer_name) {
8477                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8478                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8479                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8480                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8481                 }
8482                 if (r->manufacturer_url) {
8483                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8484                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8485                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8486                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8487                 }
8488                 if (r->hardware_id) {
8489                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8490                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8491                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8492                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8493                 }
8494                 if (r->provider) {
8495                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8496                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8497                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8498                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8499                 }
8500         }
8501         return NDR_ERR_SUCCESS;
8502 }
8503
8504 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8505 {
8506         uint32_t _ptr_driver_name;
8507         TALLOC_CTX *_mem_save_driver_name_0;
8508         uint32_t _ptr_architecture;
8509         TALLOC_CTX *_mem_save_architecture_0;
8510         uint32_t _ptr_driver_path;
8511         TALLOC_CTX *_mem_save_driver_path_0;
8512         uint32_t _ptr_data_file;
8513         TALLOC_CTX *_mem_save_data_file_0;
8514         uint32_t _ptr_config_file;
8515         TALLOC_CTX *_mem_save_config_file_0;
8516         uint32_t _ptr_help_file;
8517         TALLOC_CTX *_mem_save_help_file_0;
8518         uint32_t _ptr_monitor_name;
8519         TALLOC_CTX *_mem_save_monitor_name_0;
8520         uint32_t _ptr_default_datatype;
8521         TALLOC_CTX *_mem_save_default_datatype_0;
8522         uint32_t _ptr_dependent_files;
8523         TALLOC_CTX *_mem_save_dependent_files_0;
8524         uint32_t _ptr_previous_names;
8525         TALLOC_CTX *_mem_save_previous_names_0;
8526         uint32_t _ptr_manufacturer_name;
8527         TALLOC_CTX *_mem_save_manufacturer_name_0;
8528         uint32_t _ptr_manufacturer_url;
8529         TALLOC_CTX *_mem_save_manufacturer_url_0;
8530         uint32_t _ptr_hardware_id;
8531         TALLOC_CTX *_mem_save_hardware_id_0;
8532         uint32_t _ptr_provider;
8533         TALLOC_CTX *_mem_save_provider_0;
8534         if (ndr_flags & NDR_SCALARS) {
8535                 NDR_CHECK(ndr_pull_align(ndr, 8));
8536                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8538                 if (_ptr_driver_name) {
8539                         NDR_PULL_ALLOC(ndr, r->driver_name);
8540                 } else {
8541                         r->driver_name = NULL;
8542                 }
8543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8544                 if (_ptr_architecture) {
8545                         NDR_PULL_ALLOC(ndr, r->architecture);
8546                 } else {
8547                         r->architecture = NULL;
8548                 }
8549                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8550                 if (_ptr_driver_path) {
8551                         NDR_PULL_ALLOC(ndr, r->driver_path);
8552                 } else {
8553                         r->driver_path = NULL;
8554                 }
8555                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8556                 if (_ptr_data_file) {
8557                         NDR_PULL_ALLOC(ndr, r->data_file);
8558                 } else {
8559                         r->data_file = NULL;
8560                 }
8561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8562                 if (_ptr_config_file) {
8563                         NDR_PULL_ALLOC(ndr, r->config_file);
8564                 } else {
8565                         r->config_file = NULL;
8566                 }
8567                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8568                 if (_ptr_help_file) {
8569                         NDR_PULL_ALLOC(ndr, r->help_file);
8570                 } else {
8571                         r->help_file = NULL;
8572                 }
8573                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8574                 if (_ptr_monitor_name) {
8575                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8576                 } else {
8577                         r->monitor_name = NULL;
8578                 }
8579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8580                 if (_ptr_default_datatype) {
8581                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8582                 } else {
8583                         r->default_datatype = NULL;
8584                 }
8585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8586                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8587                 if (_ptr_dependent_files) {
8588                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8589                 } else {
8590                         r->dependent_files = NULL;
8591                 }
8592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8593                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8594                 if (_ptr_previous_names) {
8595                         NDR_PULL_ALLOC(ndr, r->previous_names);
8596                 } else {
8597                         r->previous_names = NULL;
8598                 }
8599                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8600                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8602                 if (_ptr_manufacturer_name) {
8603                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8604                 } else {
8605                         r->manufacturer_name = NULL;
8606                 }
8607                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8608                 if (_ptr_manufacturer_url) {
8609                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8610                 } else {
8611                         r->manufacturer_url = NULL;
8612                 }
8613                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8614                 if (_ptr_hardware_id) {
8615                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8616                 } else {
8617                         r->hardware_id = NULL;
8618                 }
8619                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8620                 if (_ptr_provider) {
8621                         NDR_PULL_ALLOC(ndr, r->provider);
8622                 } else {
8623                         r->provider = NULL;
8624                 }
8625         }
8626         if (ndr_flags & NDR_BUFFERS) {
8627                 if (r->driver_name) {
8628                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8629                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8630                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8631                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8632                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8633                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8634                         }
8635                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8636                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8637                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8638                 }
8639                 if (r->architecture) {
8640                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8641                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8642                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8643                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8644                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8645                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8646                         }
8647                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8648                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8650                 }
8651                 if (r->driver_path) {
8652                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8653                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8654                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8655                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8656                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8657                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8658                         }
8659                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8660                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8661                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8662                 }
8663                 if (r->data_file) {
8664                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8665                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8666                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8667                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8668                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8669                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8670                         }
8671                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8672                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8673                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8674                 }
8675                 if (r->config_file) {
8676                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8677                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8678                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8679                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8680                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8681                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8682                         }
8683                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8684                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8685                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8686                 }
8687                 if (r->help_file) {
8688                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8689                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8690                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8691                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8692                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8693                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8694                         }
8695                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8696                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8697                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8698                 }
8699                 if (r->monitor_name) {
8700                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8701                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8702                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8703                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8704                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8705                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
8706                         }
8707                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8708                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8709                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8710                 }
8711                 if (r->default_datatype) {
8712                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8713                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8714                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8715                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8716                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8717                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8718                         }
8719                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8720                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8721                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8722                 }
8723                 if (r->dependent_files) {
8724                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8725                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8726                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8727                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8728                 }
8729                 if (r->previous_names) {
8730                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8731                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8732                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8733                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8734                 }
8735                 if (r->manufacturer_name) {
8736                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8737                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8738                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8739                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8740                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8741                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
8742                         }
8743                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8744                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8745                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8746                 }
8747                 if (r->manufacturer_url) {
8748                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8749                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8750                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8751                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8752                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8753                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
8754                         }
8755                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8756                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8757                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8758                 }
8759                 if (r->hardware_id) {
8760                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8761                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8762                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8763                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8764                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8765                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
8766                         }
8767                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8768                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8769                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8770                 }
8771                 if (r->provider) {
8772                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8773                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8774                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8775                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8776                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8777                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
8778                         }
8779                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8780                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8781                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8782                 }
8783         }
8784         return NDR_ERR_SUCCESS;
8785 }
8786
8787 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8788 {
8789         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8790         ndr->depth++;
8791         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8792         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8793         ndr->depth++;
8794         if (r->driver_name) {
8795                 ndr_print_string(ndr, "driver_name", r->driver_name);
8796         }
8797         ndr->depth--;
8798         ndr_print_ptr(ndr, "architecture", r->architecture);
8799         ndr->depth++;
8800         if (r->architecture) {
8801                 ndr_print_string(ndr, "architecture", r->architecture);
8802         }
8803         ndr->depth--;
8804         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8805         ndr->depth++;
8806         if (r->driver_path) {
8807                 ndr_print_string(ndr, "driver_path", r->driver_path);
8808         }
8809         ndr->depth--;
8810         ndr_print_ptr(ndr, "data_file", r->data_file);
8811         ndr->depth++;
8812         if (r->data_file) {
8813                 ndr_print_string(ndr, "data_file", r->data_file);
8814         }
8815         ndr->depth--;
8816         ndr_print_ptr(ndr, "config_file", r->config_file);
8817         ndr->depth++;
8818         if (r->config_file) {
8819                 ndr_print_string(ndr, "config_file", r->config_file);
8820         }
8821         ndr->depth--;
8822         ndr_print_ptr(ndr, "help_file", r->help_file);
8823         ndr->depth++;
8824         if (r->help_file) {
8825                 ndr_print_string(ndr, "help_file", r->help_file);
8826         }
8827         ndr->depth--;
8828         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8829         ndr->depth++;
8830         if (r->monitor_name) {
8831                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8832         }
8833         ndr->depth--;
8834         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8835         ndr->depth++;
8836         if (r->default_datatype) {
8837                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8838         }
8839         ndr->depth--;
8840         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
8841         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8842         ndr->depth++;
8843         if (r->dependent_files) {
8844                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8845         }
8846         ndr->depth--;
8847         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
8848         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8849         ndr->depth++;
8850         if (r->previous_names) {
8851                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8852         }
8853         ndr->depth--;
8854         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8855         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8856         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8857         ndr->depth++;
8858         if (r->manufacturer_name) {
8859                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8860         }
8861         ndr->depth--;
8862         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8863         ndr->depth++;
8864         if (r->manufacturer_url) {
8865                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8866         }
8867         ndr->depth--;
8868         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8869         ndr->depth++;
8870         if (r->hardware_id) {
8871                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8872         }
8873         ndr->depth--;
8874         ndr_print_ptr(ndr, "provider", r->provider);
8875         ndr->depth++;
8876         if (r->provider) {
8877                 ndr_print_string(ndr, "provider", r->provider);
8878         }
8879         ndr->depth--;
8880         ndr->depth--;
8881 }
8882
8883 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8884 {
8885         if (ndr_flags & NDR_SCALARS) {
8886                 NDR_CHECK(ndr_push_align(ndr, 8));
8887                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8889                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8890                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8892                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8893                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8894                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8895                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8896                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8899                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8900                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8901                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8902                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8903                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8905                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8906                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8907                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8909                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8910                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8912                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8913                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8914                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8915                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8916         }
8917         if (ndr_flags & NDR_BUFFERS) {
8918                 if (r->driver_name) {
8919                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8920                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8922                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8923                 }
8924                 if (r->architecture) {
8925                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8926                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8928                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8929                 }
8930                 if (r->driver_path) {
8931                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8932                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8934                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8935                 }
8936                 if (r->data_file) {
8937                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8938                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8940                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8941                 }
8942                 if (r->config_file) {
8943                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8944                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8946                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8947                 }
8948                 if (r->help_file) {
8949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8950                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8951                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8952                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8953                 }
8954                 if (r->monitor_name) {
8955                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8956                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8958                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8959                 }
8960                 if (r->default_datatype) {
8961                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8962                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8963                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8964                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8965                 }
8966                 if (r->dependent_files) {
8967                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8968                 }
8969                 if (r->previous_names) {
8970                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8971                 }
8972                 if (r->manufacturer_name) {
8973                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8974                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8976                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8977                 }
8978                 if (r->manufacturer_url) {
8979                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8980                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8982                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8983                 }
8984                 if (r->hardware_id) {
8985                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8986                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8987                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8988                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8989                 }
8990                 if (r->provider) {
8991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8993                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8994                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8995                 }
8996                 if (r->print_processor) {
8997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
9000                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9001                 }
9002                 if (r->vendor_setup) {
9003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
9006                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9007                 }
9008                 if (r->color_profiles) {
9009                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9010                 }
9011                 if (r->inf_path) {
9012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9013                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
9014                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
9015                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
9016                 }
9017                 if (r->core_driver_dependencies) {
9018                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9019                 }
9020         }
9021         return NDR_ERR_SUCCESS;
9022 }
9023
9024 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9025 {
9026         uint32_t _ptr_driver_name;
9027         TALLOC_CTX *_mem_save_driver_name_0;
9028         uint32_t _ptr_architecture;
9029         TALLOC_CTX *_mem_save_architecture_0;
9030         uint32_t _ptr_driver_path;
9031         TALLOC_CTX *_mem_save_driver_path_0;
9032         uint32_t _ptr_data_file;
9033         TALLOC_CTX *_mem_save_data_file_0;
9034         uint32_t _ptr_config_file;
9035         TALLOC_CTX *_mem_save_config_file_0;
9036         uint32_t _ptr_help_file;
9037         TALLOC_CTX *_mem_save_help_file_0;
9038         uint32_t _ptr_monitor_name;
9039         TALLOC_CTX *_mem_save_monitor_name_0;
9040         uint32_t _ptr_default_datatype;
9041         TALLOC_CTX *_mem_save_default_datatype_0;
9042         uint32_t _ptr_dependent_files;
9043         TALLOC_CTX *_mem_save_dependent_files_0;
9044         uint32_t _ptr_previous_names;
9045         TALLOC_CTX *_mem_save_previous_names_0;
9046         uint32_t _ptr_manufacturer_name;
9047         TALLOC_CTX *_mem_save_manufacturer_name_0;
9048         uint32_t _ptr_manufacturer_url;
9049         TALLOC_CTX *_mem_save_manufacturer_url_0;
9050         uint32_t _ptr_hardware_id;
9051         TALLOC_CTX *_mem_save_hardware_id_0;
9052         uint32_t _ptr_provider;
9053         TALLOC_CTX *_mem_save_provider_0;
9054         uint32_t _ptr_print_processor;
9055         TALLOC_CTX *_mem_save_print_processor_0;
9056         uint32_t _ptr_vendor_setup;
9057         TALLOC_CTX *_mem_save_vendor_setup_0;
9058         uint32_t _ptr_color_profiles;
9059         TALLOC_CTX *_mem_save_color_profiles_0;
9060         uint32_t _ptr_inf_path;
9061         TALLOC_CTX *_mem_save_inf_path_0;
9062         uint32_t _ptr_core_driver_dependencies;
9063         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9064         if (ndr_flags & NDR_SCALARS) {
9065                 NDR_CHECK(ndr_pull_align(ndr, 8));
9066                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9067                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9068                 if (_ptr_driver_name) {
9069                         NDR_PULL_ALLOC(ndr, r->driver_name);
9070                 } else {
9071                         r->driver_name = NULL;
9072                 }
9073                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9074                 if (_ptr_architecture) {
9075                         NDR_PULL_ALLOC(ndr, r->architecture);
9076                 } else {
9077                         r->architecture = NULL;
9078                 }
9079                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9080                 if (_ptr_driver_path) {
9081                         NDR_PULL_ALLOC(ndr, r->driver_path);
9082                 } else {
9083                         r->driver_path = NULL;
9084                 }
9085                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9086                 if (_ptr_data_file) {
9087                         NDR_PULL_ALLOC(ndr, r->data_file);
9088                 } else {
9089                         r->data_file = NULL;
9090                 }
9091                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9092                 if (_ptr_config_file) {
9093                         NDR_PULL_ALLOC(ndr, r->config_file);
9094                 } else {
9095                         r->config_file = NULL;
9096                 }
9097                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9098                 if (_ptr_help_file) {
9099                         NDR_PULL_ALLOC(ndr, r->help_file);
9100                 } else {
9101                         r->help_file = NULL;
9102                 }
9103                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9104                 if (_ptr_monitor_name) {
9105                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9106                 } else {
9107                         r->monitor_name = NULL;
9108                 }
9109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9110                 if (_ptr_default_datatype) {
9111                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9112                 } else {
9113                         r->default_datatype = NULL;
9114                 }
9115                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9116                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9117                 if (_ptr_dependent_files) {
9118                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9119                 } else {
9120                         r->dependent_files = NULL;
9121                 }
9122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9123                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9124                 if (_ptr_previous_names) {
9125                         NDR_PULL_ALLOC(ndr, r->previous_names);
9126                 } else {
9127                         r->previous_names = NULL;
9128                 }
9129                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9130                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9131                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9132                 if (_ptr_manufacturer_name) {
9133                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9134                 } else {
9135                         r->manufacturer_name = NULL;
9136                 }
9137                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9138                 if (_ptr_manufacturer_url) {
9139                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9140                 } else {
9141                         r->manufacturer_url = NULL;
9142                 }
9143                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9144                 if (_ptr_hardware_id) {
9145                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9146                 } else {
9147                         r->hardware_id = NULL;
9148                 }
9149                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9150                 if (_ptr_provider) {
9151                         NDR_PULL_ALLOC(ndr, r->provider);
9152                 } else {
9153                         r->provider = NULL;
9154                 }
9155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9156                 if (_ptr_print_processor) {
9157                         NDR_PULL_ALLOC(ndr, r->print_processor);
9158                 } else {
9159                         r->print_processor = NULL;
9160                 }
9161                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9162                 if (_ptr_vendor_setup) {
9163                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9164                 } else {
9165                         r->vendor_setup = NULL;
9166                 }
9167                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9168                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9169                 if (_ptr_color_profiles) {
9170                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9171                 } else {
9172                         r->color_profiles = NULL;
9173                 }
9174                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9175                 if (_ptr_inf_path) {
9176                         NDR_PULL_ALLOC(ndr, r->inf_path);
9177                 } else {
9178                         r->inf_path = NULL;
9179                 }
9180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9182                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9183                 if (_ptr_core_driver_dependencies) {
9184                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9185                 } else {
9186                         r->core_driver_dependencies = NULL;
9187                 }
9188                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9189                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9190         }
9191         if (ndr_flags & NDR_BUFFERS) {
9192                 if (r->driver_name) {
9193                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9194                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9195                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9196                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9197                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9198                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9199                         }
9200                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9201                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9202                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9203                 }
9204                 if (r->architecture) {
9205                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9206                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9207                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9208                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9209                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9210                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9211                         }
9212                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9213                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9214                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9215                 }
9216                 if (r->driver_path) {
9217                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9218                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9219                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9220                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9221                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9222                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9223                         }
9224                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9225                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9226                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9227                 }
9228                 if (r->data_file) {
9229                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9230                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9231                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9232                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9233                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9234                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9235                         }
9236                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9237                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9238                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9239                 }
9240                 if (r->config_file) {
9241                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9242                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9243                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9244                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9245                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9246                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9247                         }
9248                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9249                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9250                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9251                 }
9252                 if (r->help_file) {
9253                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9254                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9255                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9256                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9257                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9258                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9259                         }
9260                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9261                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9262                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9263                 }
9264                 if (r->monitor_name) {
9265                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9266                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9267                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9268                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9269                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9270                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->monitor_name), ndr_get_array_length(ndr, &r->monitor_name));
9271                         }
9272                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9273                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9274                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9275                 }
9276                 if (r->default_datatype) {
9277                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9278                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9279                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9280                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9281                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9282                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9283                         }
9284                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9285                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9286                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9287                 }
9288                 if (r->dependent_files) {
9289                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9290                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9291                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9292                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9293                 }
9294                 if (r->previous_names) {
9295                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9296                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9297                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9299                 }
9300                 if (r->manufacturer_name) {
9301                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9302                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9303                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9304                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9305                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9306                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9307                         }
9308                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9309                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9310                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9311                 }
9312                 if (r->manufacturer_url) {
9313                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9314                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9315                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9316                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9317                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9318                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9319                         }
9320                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9321                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9322                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9323                 }
9324                 if (r->hardware_id) {
9325                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9326                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9327                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9328                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9329                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9330                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9331                         }
9332                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9333                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9334                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9335                 }
9336                 if (r->provider) {
9337                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9338                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9339                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9340                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9341                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9342                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9343                         }
9344                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9345                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9346                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9347                 }
9348                 if (r->print_processor) {
9349                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9350                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9351                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9352                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9353                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9354                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->print_processor), ndr_get_array_length(ndr, &r->print_processor));
9355                         }
9356                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9357                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9359                 }
9360                 if (r->vendor_setup) {
9361                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9362                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9363                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9364                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9365                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9366                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->vendor_setup), ndr_get_array_length(ndr, &r->vendor_setup));
9367                         }
9368                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9369                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9370                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9371                 }
9372                 if (r->color_profiles) {
9373                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9374                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9375                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9376                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9377                 }
9378                 if (r->inf_path) {
9379                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9380                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9381                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9382                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9383                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9384                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->inf_path), ndr_get_array_length(ndr, &r->inf_path));
9385                         }
9386                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9387                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9388                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9389                 }
9390                 if (r->core_driver_dependencies) {
9391                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9392                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9393                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9394                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9395                 }
9396         }
9397         return NDR_ERR_SUCCESS;
9398 }
9399
9400 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9401 {
9402         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9403         ndr->depth++;
9404         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9405         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9406         ndr->depth++;
9407         if (r->driver_name) {
9408                 ndr_print_string(ndr, "driver_name", r->driver_name);
9409         }
9410         ndr->depth--;
9411         ndr_print_ptr(ndr, "architecture", r->architecture);
9412         ndr->depth++;
9413         if (r->architecture) {
9414                 ndr_print_string(ndr, "architecture", r->architecture);
9415         }
9416         ndr->depth--;
9417         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9418         ndr->depth++;
9419         if (r->driver_path) {
9420                 ndr_print_string(ndr, "driver_path", r->driver_path);
9421         }
9422         ndr->depth--;
9423         ndr_print_ptr(ndr, "data_file", r->data_file);
9424         ndr->depth++;
9425         if (r->data_file) {
9426                 ndr_print_string(ndr, "data_file", r->data_file);
9427         }
9428         ndr->depth--;
9429         ndr_print_ptr(ndr, "config_file", r->config_file);
9430         ndr->depth++;
9431         if (r->config_file) {
9432                 ndr_print_string(ndr, "config_file", r->config_file);
9433         }
9434         ndr->depth--;
9435         ndr_print_ptr(ndr, "help_file", r->help_file);
9436         ndr->depth++;
9437         if (r->help_file) {
9438                 ndr_print_string(ndr, "help_file", r->help_file);
9439         }
9440         ndr->depth--;
9441         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9442         ndr->depth++;
9443         if (r->monitor_name) {
9444                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9445         }
9446         ndr->depth--;
9447         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9448         ndr->depth++;
9449         if (r->default_datatype) {
9450                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9451         }
9452         ndr->depth--;
9453         ndr_print_uint32(ndr, "_ndr_size_dependent_files", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_dependent_files);
9454         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9455         ndr->depth++;
9456         if (r->dependent_files) {
9457                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9458         }
9459         ndr->depth--;
9460         ndr_print_uint32(ndr, "_ndr_size_previous_names", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_previous_names);
9461         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9462         ndr->depth++;
9463         if (r->previous_names) {
9464                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9465         }
9466         ndr->depth--;
9467         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9468         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9469         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9470         ndr->depth++;
9471         if (r->manufacturer_name) {
9472                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9473         }
9474         ndr->depth--;
9475         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9476         ndr->depth++;
9477         if (r->manufacturer_url) {
9478                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9479         }
9480         ndr->depth--;
9481         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9482         ndr->depth++;
9483         if (r->hardware_id) {
9484                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9485         }
9486         ndr->depth--;
9487         ndr_print_ptr(ndr, "provider", r->provider);
9488         ndr->depth++;
9489         if (r->provider) {
9490                 ndr_print_string(ndr, "provider", r->provider);
9491         }
9492         ndr->depth--;
9493         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9494         ndr->depth++;
9495         if (r->print_processor) {
9496                 ndr_print_string(ndr, "print_processor", r->print_processor);
9497         }
9498         ndr->depth--;
9499         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9500         ndr->depth++;
9501         if (r->vendor_setup) {
9502                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9503         }
9504         ndr->depth--;
9505         ndr_print_uint32(ndr, "_ndr_size_color_profiles", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_color_profiles);
9506         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9507         ndr->depth++;
9508         if (r->color_profiles) {
9509                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9510         }
9511         ndr->depth--;
9512         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9513         ndr->depth++;
9514         if (r->inf_path) {
9515                 ndr_print_string(ndr, "inf_path", r->inf_path);
9516         }
9517         ndr->depth--;
9518         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9519         ndr_print_uint32(ndr, "_ndr_size_core_driver_dependencies", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2):r->_ndr_size_core_driver_dependencies);
9520         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9521         ndr->depth++;
9522         if (r->core_driver_dependencies) {
9523                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9524         }
9525         ndr->depth--;
9526         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9527         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9528         ndr->depth--;
9529 }
9530
9531 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9532 {
9533         if (ndr_flags & NDR_SCALARS) {
9534                 int level = ndr_push_get_switch_value(ndr, r);
9535                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9536                 switch (level) {
9537                         case 1: {
9538                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9539                         break; }
9540
9541                         case 2: {
9542                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9543                         break; }
9544
9545                         case 3: {
9546                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9547                         break; }
9548
9549                         case 4: {
9550                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9551                         break; }
9552
9553                         case 6: {
9554                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9555                         break; }
9556
9557                         case 8: {
9558                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9559                         break; }
9560
9561                         default:
9562                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9563                 }
9564         }
9565         if (ndr_flags & NDR_BUFFERS) {
9566                 int level = ndr_push_get_switch_value(ndr, r);
9567                 switch (level) {
9568                         case 1:
9569                                 if (r->info1) {
9570                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9571                                 }
9572                         break;
9573
9574                         case 2:
9575                                 if (r->info2) {
9576                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9577                                 }
9578                         break;
9579
9580                         case 3:
9581                                 if (r->info3) {
9582                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9583                                 }
9584                         break;
9585
9586                         case 4:
9587                                 if (r->info4) {
9588                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9589                                 }
9590                         break;
9591
9592                         case 6:
9593                                 if (r->info6) {
9594                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9595                                 }
9596                         break;
9597
9598                         case 8:
9599                                 if (r->info8) {
9600                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9601                                 }
9602                         break;
9603
9604                         default:
9605                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9606                 }
9607         }
9608         return NDR_ERR_SUCCESS;
9609 }
9610
9611 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9612 {
9613         int level;
9614         uint32_t _level;
9615         TALLOC_CTX *_mem_save_info1_0;
9616         TALLOC_CTX *_mem_save_info2_0;
9617         TALLOC_CTX *_mem_save_info3_0;
9618         TALLOC_CTX *_mem_save_info4_0;
9619         TALLOC_CTX *_mem_save_info6_0;
9620         TALLOC_CTX *_mem_save_info8_0;
9621         level = ndr_pull_get_switch_value(ndr, r);
9622         if (ndr_flags & NDR_SCALARS) {
9623                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9624                 if (_level != level) {
9625                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9626                 }
9627                 switch (level) {
9628                         case 1: {
9629                                 uint32_t _ptr_info1;
9630                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9631                                 if (_ptr_info1) {
9632                                         NDR_PULL_ALLOC(ndr, r->info1);
9633                                 } else {
9634                                         r->info1 = NULL;
9635                                 }
9636                         break; }
9637
9638                         case 2: {
9639                                 uint32_t _ptr_info2;
9640                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9641                                 if (_ptr_info2) {
9642                                         NDR_PULL_ALLOC(ndr, r->info2);
9643                                 } else {
9644                                         r->info2 = NULL;
9645                                 }
9646                         break; }
9647
9648                         case 3: {
9649                                 uint32_t _ptr_info3;
9650                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9651                                 if (_ptr_info3) {
9652                                         NDR_PULL_ALLOC(ndr, r->info3);
9653                                 } else {
9654                                         r->info3 = NULL;
9655                                 }
9656                         break; }
9657
9658                         case 4: {
9659                                 uint32_t _ptr_info4;
9660                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9661                                 if (_ptr_info4) {
9662                                         NDR_PULL_ALLOC(ndr, r->info4);
9663                                 } else {
9664                                         r->info4 = NULL;
9665                                 }
9666                         break; }
9667
9668                         case 6: {
9669                                 uint32_t _ptr_info6;
9670                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9671                                 if (_ptr_info6) {
9672                                         NDR_PULL_ALLOC(ndr, r->info6);
9673                                 } else {
9674                                         r->info6 = NULL;
9675                                 }
9676                         break; }
9677
9678                         case 8: {
9679                                 uint32_t _ptr_info8;
9680                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9681                                 if (_ptr_info8) {
9682                                         NDR_PULL_ALLOC(ndr, r->info8);
9683                                 } else {
9684                                         r->info8 = NULL;
9685                                 }
9686                         break; }
9687
9688                         default:
9689                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9690                 }
9691         }
9692         if (ndr_flags & NDR_BUFFERS) {
9693                 switch (level) {
9694                         case 1:
9695                                 if (r->info1) {
9696                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9697                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9698                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9699                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9700                                 }
9701                         break;
9702
9703                         case 2:
9704                                 if (r->info2) {
9705                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9706                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9707                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9708                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9709                                 }
9710                         break;
9711
9712                         case 3:
9713                                 if (r->info3) {
9714                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9715                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9716                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9717                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9718                                 }
9719                         break;
9720
9721                         case 4:
9722                                 if (r->info4) {
9723                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9724                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9725                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9726                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9727                                 }
9728                         break;
9729
9730                         case 6:
9731                                 if (r->info6) {
9732                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9733                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9734                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9735                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9736                                 }
9737                         break;
9738
9739                         case 8:
9740                                 if (r->info8) {
9741                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9742                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9743                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9744                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9745                                 }
9746                         break;
9747
9748                         default:
9749                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9750                 }
9751         }
9752         return NDR_ERR_SUCCESS;
9753 }
9754
9755 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9756 {
9757         int level;
9758         level = ndr_print_get_switch_value(ndr, r);
9759         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9760         switch (level) {
9761                 case 1:
9762                         ndr_print_ptr(ndr, "info1", r->info1);
9763                         ndr->depth++;
9764                         if (r->info1) {
9765                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9766                         }
9767                         ndr->depth--;
9768                 break;
9769
9770                 case 2:
9771                         ndr_print_ptr(ndr, "info2", r->info2);
9772                         ndr->depth++;
9773                         if (r->info2) {
9774                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9775                         }
9776                         ndr->depth--;
9777                 break;
9778
9779                 case 3:
9780                         ndr_print_ptr(ndr, "info3", r->info3);
9781                         ndr->depth++;
9782                         if (r->info3) {
9783                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9784                         }
9785                         ndr->depth--;
9786                 break;
9787
9788                 case 4:
9789                         ndr_print_ptr(ndr, "info4", r->info4);
9790                         ndr->depth++;
9791                         if (r->info4) {
9792                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9793                         }
9794                         ndr->depth--;
9795                 break;
9796
9797                 case 6:
9798                         ndr_print_ptr(ndr, "info6", r->info6);
9799                         ndr->depth++;
9800                         if (r->info6) {
9801                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9802                         }
9803                         ndr->depth--;
9804                 break;
9805
9806                 case 8:
9807                         ndr_print_ptr(ndr, "info8", r->info8);
9808                         ndr->depth++;
9809                         if (r->info8) {
9810                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9811                         }
9812                         ndr->depth--;
9813                 break;
9814
9815                 default:
9816                         ndr_print_bad_level(ndr, name, level);
9817         }
9818 }
9819
9820 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9821 {
9822         if (ndr_flags & NDR_SCALARS) {
9823                 NDR_CHECK(ndr_push_align(ndr, 4));
9824                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9825                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9826                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9827         }
9828         if (ndr_flags & NDR_BUFFERS) {
9829                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9830         }
9831         return NDR_ERR_SUCCESS;
9832 }
9833
9834 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9835 {
9836         if (ndr_flags & NDR_SCALARS) {
9837                 NDR_CHECK(ndr_pull_align(ndr, 4));
9838                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9839                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9840                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9841         }
9842         if (ndr_flags & NDR_BUFFERS) {
9843                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9844         }
9845         return NDR_ERR_SUCCESS;
9846 }
9847
9848 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9849 {
9850         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9851         ndr->depth++;
9852         ndr_print_uint32(ndr, "level", r->level);
9853         ndr_print_set_switch_value(ndr, &r->info, r->level);
9854         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9855         ndr->depth--;
9856 }
9857
9858 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9859 {
9860         if (ndr_flags & NDR_SCALARS) {
9861                 NDR_CHECK(ndr_push_align(ndr, 4));
9862                 {
9863                         uint32_t _flags_save_string = ndr->flags;
9864                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9865                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9866                         ndr->flags = _flags_save_string;
9867                 }
9868         }
9869         if (ndr_flags & NDR_BUFFERS) {
9870                 {
9871                         uint32_t _flags_save_string = ndr->flags;
9872                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9873                         if (r->driver_name) {
9874                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9875                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9876                         }
9877                         ndr->flags = _flags_save_string;
9878                 }
9879         }
9880         return NDR_ERR_SUCCESS;
9881 }
9882
9883 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9884 {
9885         uint32_t _ptr_driver_name;
9886         TALLOC_CTX *_mem_save_driver_name_0;
9887         if (ndr_flags & NDR_SCALARS) {
9888                 NDR_CHECK(ndr_pull_align(ndr, 4));
9889                 {
9890                         uint32_t _flags_save_string = ndr->flags;
9891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9892                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9893                         if (_ptr_driver_name) {
9894                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9895                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9896                         } else {
9897                                 r->driver_name = NULL;
9898                         }
9899                         ndr->flags = _flags_save_string;
9900                 }
9901         }
9902         if (ndr_flags & NDR_BUFFERS) {
9903                 {
9904                         uint32_t _flags_save_string = ndr->flags;
9905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9906                         if (r->driver_name) {
9907                                 uint32_t _relative_save_offset;
9908                                 _relative_save_offset = ndr->offset;
9909                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9910                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9911                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9912                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9913                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9914                                 ndr->offset = _relative_save_offset;
9915                         }
9916                         ndr->flags = _flags_save_string;
9917                 }
9918         }
9919         return NDR_ERR_SUCCESS;
9920 }
9921
9922 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9923 {
9924         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9925         ndr->depth++;
9926         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9927         ndr->depth++;
9928         if (r->driver_name) {
9929                 ndr_print_string(ndr, "driver_name", r->driver_name);
9930         }
9931         ndr->depth--;
9932         ndr->depth--;
9933 }
9934
9935 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9936 {
9937         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9938 }
9939
9940 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9941 {
9942         if (ndr_flags & NDR_SCALARS) {
9943                 NDR_CHECK(ndr_push_align(ndr, 4));
9944                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9945                 {
9946                         uint32_t _flags_save_string = ndr->flags;
9947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9948                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9949                         ndr->flags = _flags_save_string;
9950                 }
9951                 {
9952                         uint32_t _flags_save_string = ndr->flags;
9953                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9954                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9955                         ndr->flags = _flags_save_string;
9956                 }
9957                 {
9958                         uint32_t _flags_save_string = ndr->flags;
9959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9960                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9961                         ndr->flags = _flags_save_string;
9962                 }
9963                 {
9964                         uint32_t _flags_save_string = ndr->flags;
9965                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9966                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9967                         ndr->flags = _flags_save_string;
9968                 }
9969                 {
9970                         uint32_t _flags_save_string = ndr->flags;
9971                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9972                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9973                         ndr->flags = _flags_save_string;
9974                 }
9975         }
9976         if (ndr_flags & NDR_BUFFERS) {
9977                 {
9978                         uint32_t _flags_save_string = ndr->flags;
9979                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9980                         if (r->driver_name) {
9981                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9982                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9983                         }
9984                         ndr->flags = _flags_save_string;
9985                 }
9986                 {
9987                         uint32_t _flags_save_string = ndr->flags;
9988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9989                         if (r->architecture) {
9990                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9991                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9992                         }
9993                         ndr->flags = _flags_save_string;
9994                 }
9995                 {
9996                         uint32_t _flags_save_string = ndr->flags;
9997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9998                         if (r->driver_path) {
9999                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10000                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10001                         }
10002                         ndr->flags = _flags_save_string;
10003                 }
10004                 {
10005                         uint32_t _flags_save_string = ndr->flags;
10006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10007                         if (r->data_file) {
10008                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10009                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10010                         }
10011                         ndr->flags = _flags_save_string;
10012                 }
10013                 {
10014                         uint32_t _flags_save_string = ndr->flags;
10015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10016                         if (r->config_file) {
10017                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10018                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10019                         }
10020                         ndr->flags = _flags_save_string;
10021                 }
10022         }
10023         return NDR_ERR_SUCCESS;
10024 }
10025
10026 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10027 {
10028         uint32_t _ptr_driver_name;
10029         TALLOC_CTX *_mem_save_driver_name_0;
10030         uint32_t _ptr_architecture;
10031         TALLOC_CTX *_mem_save_architecture_0;
10032         uint32_t _ptr_driver_path;
10033         TALLOC_CTX *_mem_save_driver_path_0;
10034         uint32_t _ptr_data_file;
10035         TALLOC_CTX *_mem_save_data_file_0;
10036         uint32_t _ptr_config_file;
10037         TALLOC_CTX *_mem_save_config_file_0;
10038         if (ndr_flags & NDR_SCALARS) {
10039                 NDR_CHECK(ndr_pull_align(ndr, 4));
10040                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10041                 {
10042                         uint32_t _flags_save_string = ndr->flags;
10043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10044                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10045                         if (_ptr_driver_name) {
10046                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10047                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10048                         } else {
10049                                 r->driver_name = NULL;
10050                         }
10051                         ndr->flags = _flags_save_string;
10052                 }
10053                 {
10054                         uint32_t _flags_save_string = ndr->flags;
10055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10056                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10057                         if (_ptr_architecture) {
10058                                 NDR_PULL_ALLOC(ndr, r->architecture);
10059                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10060                         } else {
10061                                 r->architecture = NULL;
10062                         }
10063                         ndr->flags = _flags_save_string;
10064                 }
10065                 {
10066                         uint32_t _flags_save_string = ndr->flags;
10067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10068                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10069                         if (_ptr_driver_path) {
10070                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10071                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10072                         } else {
10073                                 r->driver_path = NULL;
10074                         }
10075                         ndr->flags = _flags_save_string;
10076                 }
10077                 {
10078                         uint32_t _flags_save_string = ndr->flags;
10079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10080                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10081                         if (_ptr_data_file) {
10082                                 NDR_PULL_ALLOC(ndr, r->data_file);
10083                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10084                         } else {
10085                                 r->data_file = NULL;
10086                         }
10087                         ndr->flags = _flags_save_string;
10088                 }
10089                 {
10090                         uint32_t _flags_save_string = ndr->flags;
10091                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10092                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10093                         if (_ptr_config_file) {
10094                                 NDR_PULL_ALLOC(ndr, r->config_file);
10095                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10096                         } else {
10097                                 r->config_file = NULL;
10098                         }
10099                         ndr->flags = _flags_save_string;
10100                 }
10101         }
10102         if (ndr_flags & NDR_BUFFERS) {
10103                 {
10104                         uint32_t _flags_save_string = ndr->flags;
10105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10106                         if (r->driver_name) {
10107                                 uint32_t _relative_save_offset;
10108                                 _relative_save_offset = ndr->offset;
10109                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10110                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10111                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10112                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10113                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10114                                 ndr->offset = _relative_save_offset;
10115                         }
10116                         ndr->flags = _flags_save_string;
10117                 }
10118                 {
10119                         uint32_t _flags_save_string = ndr->flags;
10120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10121                         if (r->architecture) {
10122                                 uint32_t _relative_save_offset;
10123                                 _relative_save_offset = ndr->offset;
10124                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10125                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10126                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10127                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10128                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10129                                 ndr->offset = _relative_save_offset;
10130                         }
10131                         ndr->flags = _flags_save_string;
10132                 }
10133                 {
10134                         uint32_t _flags_save_string = ndr->flags;
10135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10136                         if (r->driver_path) {
10137                                 uint32_t _relative_save_offset;
10138                                 _relative_save_offset = ndr->offset;
10139                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10140                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10141                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10142                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10143                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10144                                 ndr->offset = _relative_save_offset;
10145                         }
10146                         ndr->flags = _flags_save_string;
10147                 }
10148                 {
10149                         uint32_t _flags_save_string = ndr->flags;
10150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10151                         if (r->data_file) {
10152                                 uint32_t _relative_save_offset;
10153                                 _relative_save_offset = ndr->offset;
10154                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10155                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10156                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10157                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10158                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10159                                 ndr->offset = _relative_save_offset;
10160                         }
10161                         ndr->flags = _flags_save_string;
10162                 }
10163                 {
10164                         uint32_t _flags_save_string = ndr->flags;
10165                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10166                         if (r->config_file) {
10167                                 uint32_t _relative_save_offset;
10168                                 _relative_save_offset = ndr->offset;
10169                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10170                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10171                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10172                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10173                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10174                                 ndr->offset = _relative_save_offset;
10175                         }
10176                         ndr->flags = _flags_save_string;
10177                 }
10178         }
10179         return NDR_ERR_SUCCESS;
10180 }
10181
10182 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10183 {
10184         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10185         ndr->depth++;
10186         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10187         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10188         ndr->depth++;
10189         if (r->driver_name) {
10190                 ndr_print_string(ndr, "driver_name", r->driver_name);
10191         }
10192         ndr->depth--;
10193         ndr_print_ptr(ndr, "architecture", r->architecture);
10194         ndr->depth++;
10195         if (r->architecture) {
10196                 ndr_print_string(ndr, "architecture", r->architecture);
10197         }
10198         ndr->depth--;
10199         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10200         ndr->depth++;
10201         if (r->driver_path) {
10202                 ndr_print_string(ndr, "driver_path", r->driver_path);
10203         }
10204         ndr->depth--;
10205         ndr_print_ptr(ndr, "data_file", r->data_file);
10206         ndr->depth++;
10207         if (r->data_file) {
10208                 ndr_print_string(ndr, "data_file", r->data_file);
10209         }
10210         ndr->depth--;
10211         ndr_print_ptr(ndr, "config_file", r->config_file);
10212         ndr->depth++;
10213         if (r->config_file) {
10214                 ndr_print_string(ndr, "config_file", r->config_file);
10215         }
10216         ndr->depth--;
10217         ndr->depth--;
10218 }
10219
10220 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10221 {
10222         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10223 }
10224
10225 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10226 {
10227         if (ndr_flags & NDR_SCALARS) {
10228                 NDR_CHECK(ndr_push_align(ndr, 4));
10229                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10230                 {
10231                         uint32_t _flags_save_string = ndr->flags;
10232                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10233                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10234                         ndr->flags = _flags_save_string;
10235                 }
10236                 {
10237                         uint32_t _flags_save_string = ndr->flags;
10238                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10239                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10240                         ndr->flags = _flags_save_string;
10241                 }
10242                 {
10243                         uint32_t _flags_save_string = ndr->flags;
10244                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10245                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10246                         ndr->flags = _flags_save_string;
10247                 }
10248                 {
10249                         uint32_t _flags_save_string = ndr->flags;
10250                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10251                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10252                         ndr->flags = _flags_save_string;
10253                 }
10254                 {
10255                         uint32_t _flags_save_string = ndr->flags;
10256                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10257                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10258                         ndr->flags = _flags_save_string;
10259                 }
10260                 {
10261                         uint32_t _flags_save_string = ndr->flags;
10262                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10263                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10264                         ndr->flags = _flags_save_string;
10265                 }
10266                 {
10267                         uint32_t _flags_save_string_array = ndr->flags;
10268                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10269                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10270                         ndr->flags = _flags_save_string_array;
10271                 }
10272                 {
10273                         uint32_t _flags_save_string = ndr->flags;
10274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10275                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10276                         ndr->flags = _flags_save_string;
10277                 }
10278                 {
10279                         uint32_t _flags_save_string = ndr->flags;
10280                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10281                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10282                         ndr->flags = _flags_save_string;
10283                 }
10284         }
10285         if (ndr_flags & NDR_BUFFERS) {
10286                 {
10287                         uint32_t _flags_save_string = ndr->flags;
10288                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10289                         if (r->driver_name) {
10290                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10291                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10292                         }
10293                         ndr->flags = _flags_save_string;
10294                 }
10295                 {
10296                         uint32_t _flags_save_string = ndr->flags;
10297                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10298                         if (r->architecture) {
10299                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10300                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10301                         }
10302                         ndr->flags = _flags_save_string;
10303                 }
10304                 {
10305                         uint32_t _flags_save_string = ndr->flags;
10306                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10307                         if (r->driver_path) {
10308                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10309                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10310                         }
10311                         ndr->flags = _flags_save_string;
10312                 }
10313                 {
10314                         uint32_t _flags_save_string = ndr->flags;
10315                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10316                         if (r->data_file) {
10317                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10318                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10319                         }
10320                         ndr->flags = _flags_save_string;
10321                 }
10322                 {
10323                         uint32_t _flags_save_string = ndr->flags;
10324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10325                         if (r->config_file) {
10326                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10327                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10328                         }
10329                         ndr->flags = _flags_save_string;
10330                 }
10331                 {
10332                         uint32_t _flags_save_string = ndr->flags;
10333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10334                         if (r->help_file) {
10335                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10336                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10337                         }
10338                         ndr->flags = _flags_save_string;
10339                 }
10340                 {
10341                         uint32_t _flags_save_string_array = ndr->flags;
10342                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10343                         if (r->dependent_files) {
10344                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10345                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10346                         }
10347                         ndr->flags = _flags_save_string_array;
10348                 }
10349                 {
10350                         uint32_t _flags_save_string = ndr->flags;
10351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10352                         if (r->monitor_name) {
10353                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10354                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10355                         }
10356                         ndr->flags = _flags_save_string;
10357                 }
10358                 {
10359                         uint32_t _flags_save_string = ndr->flags;
10360                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10361                         if (r->default_datatype) {
10362                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10363                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10364                         }
10365                         ndr->flags = _flags_save_string;
10366                 }
10367         }
10368         return NDR_ERR_SUCCESS;
10369 }
10370
10371 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10372 {
10373         uint32_t _ptr_driver_name;
10374         TALLOC_CTX *_mem_save_driver_name_0;
10375         uint32_t _ptr_architecture;
10376         TALLOC_CTX *_mem_save_architecture_0;
10377         uint32_t _ptr_driver_path;
10378         TALLOC_CTX *_mem_save_driver_path_0;
10379         uint32_t _ptr_data_file;
10380         TALLOC_CTX *_mem_save_data_file_0;
10381         uint32_t _ptr_config_file;
10382         TALLOC_CTX *_mem_save_config_file_0;
10383         uint32_t _ptr_help_file;
10384         TALLOC_CTX *_mem_save_help_file_0;
10385         uint32_t _ptr_dependent_files;
10386         TALLOC_CTX *_mem_save_dependent_files_0;
10387         uint32_t _ptr_monitor_name;
10388         TALLOC_CTX *_mem_save_monitor_name_0;
10389         uint32_t _ptr_default_datatype;
10390         TALLOC_CTX *_mem_save_default_datatype_0;
10391         if (ndr_flags & NDR_SCALARS) {
10392                 NDR_CHECK(ndr_pull_align(ndr, 4));
10393                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10394                 {
10395                         uint32_t _flags_save_string = ndr->flags;
10396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10398                         if (_ptr_driver_name) {
10399                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10401                         } else {
10402                                 r->driver_name = NULL;
10403                         }
10404                         ndr->flags = _flags_save_string;
10405                 }
10406                 {
10407                         uint32_t _flags_save_string = ndr->flags;
10408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10409                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10410                         if (_ptr_architecture) {
10411                                 NDR_PULL_ALLOC(ndr, r->architecture);
10412                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10413                         } else {
10414                                 r->architecture = NULL;
10415                         }
10416                         ndr->flags = _flags_save_string;
10417                 }
10418                 {
10419                         uint32_t _flags_save_string = ndr->flags;
10420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10421                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10422                         if (_ptr_driver_path) {
10423                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10424                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10425                         } else {
10426                                 r->driver_path = NULL;
10427                         }
10428                         ndr->flags = _flags_save_string;
10429                 }
10430                 {
10431                         uint32_t _flags_save_string = ndr->flags;
10432                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10433                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10434                         if (_ptr_data_file) {
10435                                 NDR_PULL_ALLOC(ndr, r->data_file);
10436                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10437                         } else {
10438                                 r->data_file = NULL;
10439                         }
10440                         ndr->flags = _flags_save_string;
10441                 }
10442                 {
10443                         uint32_t _flags_save_string = ndr->flags;
10444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10445                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10446                         if (_ptr_config_file) {
10447                                 NDR_PULL_ALLOC(ndr, r->config_file);
10448                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10449                         } else {
10450                                 r->config_file = NULL;
10451                         }
10452                         ndr->flags = _flags_save_string;
10453                 }
10454                 {
10455                         uint32_t _flags_save_string = ndr->flags;
10456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10457                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10458                         if (_ptr_help_file) {
10459                                 NDR_PULL_ALLOC(ndr, r->help_file);
10460                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10461                         } else {
10462                                 r->help_file = NULL;
10463                         }
10464                         ndr->flags = _flags_save_string;
10465                 }
10466                 {
10467                         uint32_t _flags_save_string_array = ndr->flags;
10468                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10469                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10470                         if (_ptr_dependent_files) {
10471                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10472                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10473                         } else {
10474                                 r->dependent_files = NULL;
10475                         }
10476                         ndr->flags = _flags_save_string_array;
10477                 }
10478                 {
10479                         uint32_t _flags_save_string = ndr->flags;
10480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10481                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10482                         if (_ptr_monitor_name) {
10483                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10484                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10485                         } else {
10486                                 r->monitor_name = NULL;
10487                         }
10488                         ndr->flags = _flags_save_string;
10489                 }
10490                 {
10491                         uint32_t _flags_save_string = ndr->flags;
10492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10493                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10494                         if (_ptr_default_datatype) {
10495                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10496                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10497                         } else {
10498                                 r->default_datatype = NULL;
10499                         }
10500                         ndr->flags = _flags_save_string;
10501                 }
10502         }
10503         if (ndr_flags & NDR_BUFFERS) {
10504                 {
10505                         uint32_t _flags_save_string = ndr->flags;
10506                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10507                         if (r->driver_name) {
10508                                 uint32_t _relative_save_offset;
10509                                 _relative_save_offset = ndr->offset;
10510                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10511                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10512                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10513                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10514                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10515                                 ndr->offset = _relative_save_offset;
10516                         }
10517                         ndr->flags = _flags_save_string;
10518                 }
10519                 {
10520                         uint32_t _flags_save_string = ndr->flags;
10521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10522                         if (r->architecture) {
10523                                 uint32_t _relative_save_offset;
10524                                 _relative_save_offset = ndr->offset;
10525                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10526                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10527                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10528                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10529                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10530                                 ndr->offset = _relative_save_offset;
10531                         }
10532                         ndr->flags = _flags_save_string;
10533                 }
10534                 {
10535                         uint32_t _flags_save_string = ndr->flags;
10536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10537                         if (r->driver_path) {
10538                                 uint32_t _relative_save_offset;
10539                                 _relative_save_offset = ndr->offset;
10540                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10541                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10542                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10543                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10544                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10545                                 ndr->offset = _relative_save_offset;
10546                         }
10547                         ndr->flags = _flags_save_string;
10548                 }
10549                 {
10550                         uint32_t _flags_save_string = ndr->flags;
10551                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10552                         if (r->data_file) {
10553                                 uint32_t _relative_save_offset;
10554                                 _relative_save_offset = ndr->offset;
10555                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10556                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10557                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10558                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10559                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10560                                 ndr->offset = _relative_save_offset;
10561                         }
10562                         ndr->flags = _flags_save_string;
10563                 }
10564                 {
10565                         uint32_t _flags_save_string = ndr->flags;
10566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10567                         if (r->config_file) {
10568                                 uint32_t _relative_save_offset;
10569                                 _relative_save_offset = ndr->offset;
10570                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10571                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10572                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10573                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10574                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10575                                 ndr->offset = _relative_save_offset;
10576                         }
10577                         ndr->flags = _flags_save_string;
10578                 }
10579                 {
10580                         uint32_t _flags_save_string = ndr->flags;
10581                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10582                         if (r->help_file) {
10583                                 uint32_t _relative_save_offset;
10584                                 _relative_save_offset = ndr->offset;
10585                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10586                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10587                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10588                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10589                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10590                                 ndr->offset = _relative_save_offset;
10591                         }
10592                         ndr->flags = _flags_save_string;
10593                 }
10594                 {
10595                         uint32_t _flags_save_string_array = ndr->flags;
10596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10597                         if (r->dependent_files) {
10598                                 uint32_t _relative_save_offset;
10599                                 _relative_save_offset = ndr->offset;
10600                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10601                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10602                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10603                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10604                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10605                                 ndr->offset = _relative_save_offset;
10606                         }
10607                         ndr->flags = _flags_save_string_array;
10608                 }
10609                 {
10610                         uint32_t _flags_save_string = ndr->flags;
10611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10612                         if (r->monitor_name) {
10613                                 uint32_t _relative_save_offset;
10614                                 _relative_save_offset = ndr->offset;
10615                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10616                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10617                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10618                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10619                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10620                                 ndr->offset = _relative_save_offset;
10621                         }
10622                         ndr->flags = _flags_save_string;
10623                 }
10624                 {
10625                         uint32_t _flags_save_string = ndr->flags;
10626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10627                         if (r->default_datatype) {
10628                                 uint32_t _relative_save_offset;
10629                                 _relative_save_offset = ndr->offset;
10630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10631                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10632                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10633                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10635                                 ndr->offset = _relative_save_offset;
10636                         }
10637                         ndr->flags = _flags_save_string;
10638                 }
10639         }
10640         return NDR_ERR_SUCCESS;
10641 }
10642
10643 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10644 {
10645         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10646         ndr->depth++;
10647         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10648         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10649         ndr->depth++;
10650         if (r->driver_name) {
10651                 ndr_print_string(ndr, "driver_name", r->driver_name);
10652         }
10653         ndr->depth--;
10654         ndr_print_ptr(ndr, "architecture", r->architecture);
10655         ndr->depth++;
10656         if (r->architecture) {
10657                 ndr_print_string(ndr, "architecture", r->architecture);
10658         }
10659         ndr->depth--;
10660         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10661         ndr->depth++;
10662         if (r->driver_path) {
10663                 ndr_print_string(ndr, "driver_path", r->driver_path);
10664         }
10665         ndr->depth--;
10666         ndr_print_ptr(ndr, "data_file", r->data_file);
10667         ndr->depth++;
10668         if (r->data_file) {
10669                 ndr_print_string(ndr, "data_file", r->data_file);
10670         }
10671         ndr->depth--;
10672         ndr_print_ptr(ndr, "config_file", r->config_file);
10673         ndr->depth++;
10674         if (r->config_file) {
10675                 ndr_print_string(ndr, "config_file", r->config_file);
10676         }
10677         ndr->depth--;
10678         ndr_print_ptr(ndr, "help_file", r->help_file);
10679         ndr->depth++;
10680         if (r->help_file) {
10681                 ndr_print_string(ndr, "help_file", r->help_file);
10682         }
10683         ndr->depth--;
10684         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10685         ndr->depth++;
10686         if (r->dependent_files) {
10687                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10688         }
10689         ndr->depth--;
10690         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10691         ndr->depth++;
10692         if (r->monitor_name) {
10693                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10694         }
10695         ndr->depth--;
10696         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10697         ndr->depth++;
10698         if (r->default_datatype) {
10699                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10700         }
10701         ndr->depth--;
10702         ndr->depth--;
10703 }
10704
10705 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10706 {
10707         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10708 }
10709
10710 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10711 {
10712         if (ndr_flags & NDR_SCALARS) {
10713                 NDR_CHECK(ndr_push_align(ndr, 4));
10714                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10715                 {
10716                         uint32_t _flags_save_string = ndr->flags;
10717                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10718                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10719                         ndr->flags = _flags_save_string;
10720                 }
10721                 {
10722                         uint32_t _flags_save_string = ndr->flags;
10723                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10724                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10725                         ndr->flags = _flags_save_string;
10726                 }
10727                 {
10728                         uint32_t _flags_save_string = ndr->flags;
10729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10730                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10731                         ndr->flags = _flags_save_string;
10732                 }
10733                 {
10734                         uint32_t _flags_save_string = ndr->flags;
10735                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10736                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10737                         ndr->flags = _flags_save_string;
10738                 }
10739                 {
10740                         uint32_t _flags_save_string = ndr->flags;
10741                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10742                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10743                         ndr->flags = _flags_save_string;
10744                 }
10745                 {
10746                         uint32_t _flags_save_string = ndr->flags;
10747                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10748                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10749                         ndr->flags = _flags_save_string;
10750                 }
10751                 {
10752                         uint32_t _flags_save_string_array = ndr->flags;
10753                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10754                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10755                         ndr->flags = _flags_save_string_array;
10756                 }
10757                 {
10758                         uint32_t _flags_save_string = ndr->flags;
10759                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10760                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10761                         ndr->flags = _flags_save_string;
10762                 }
10763                 {
10764                         uint32_t _flags_save_string = ndr->flags;
10765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10766                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10767                         ndr->flags = _flags_save_string;
10768                 }
10769                 {
10770                         uint32_t _flags_save_string_array = ndr->flags;
10771                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10772                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10773                         ndr->flags = _flags_save_string_array;
10774                 }
10775         }
10776         if (ndr_flags & NDR_BUFFERS) {
10777                 {
10778                         uint32_t _flags_save_string = ndr->flags;
10779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10780                         if (r->driver_name) {
10781                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10782                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10783                         }
10784                         ndr->flags = _flags_save_string;
10785                 }
10786                 {
10787                         uint32_t _flags_save_string = ndr->flags;
10788                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10789                         if (r->architecture) {
10790                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10791                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10792                         }
10793                         ndr->flags = _flags_save_string;
10794                 }
10795                 {
10796                         uint32_t _flags_save_string = ndr->flags;
10797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10798                         if (r->driver_path) {
10799                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10800                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10801                         }
10802                         ndr->flags = _flags_save_string;
10803                 }
10804                 {
10805                         uint32_t _flags_save_string = ndr->flags;
10806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10807                         if (r->data_file) {
10808                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10809                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10810                         }
10811                         ndr->flags = _flags_save_string;
10812                 }
10813                 {
10814                         uint32_t _flags_save_string = ndr->flags;
10815                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10816                         if (r->config_file) {
10817                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10818                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10819                         }
10820                         ndr->flags = _flags_save_string;
10821                 }
10822                 {
10823                         uint32_t _flags_save_string = ndr->flags;
10824                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10825                         if (r->help_file) {
10826                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10827                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10828                         }
10829                         ndr->flags = _flags_save_string;
10830                 }
10831                 {
10832                         uint32_t _flags_save_string_array = ndr->flags;
10833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10834                         if (r->dependent_files) {
10835                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10836                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10837                         }
10838                         ndr->flags = _flags_save_string_array;
10839                 }
10840                 {
10841                         uint32_t _flags_save_string = ndr->flags;
10842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10843                         if (r->monitor_name) {
10844                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10845                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10846                         }
10847                         ndr->flags = _flags_save_string;
10848                 }
10849                 {
10850                         uint32_t _flags_save_string = ndr->flags;
10851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10852                         if (r->default_datatype) {
10853                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10854                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10855                         }
10856                         ndr->flags = _flags_save_string;
10857                 }
10858                 {
10859                         uint32_t _flags_save_string_array = ndr->flags;
10860                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10861                         if (r->previous_names) {
10862                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10863                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10864                         }
10865                         ndr->flags = _flags_save_string_array;
10866                 }
10867         }
10868         return NDR_ERR_SUCCESS;
10869 }
10870
10871 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10872 {
10873         uint32_t _ptr_driver_name;
10874         TALLOC_CTX *_mem_save_driver_name_0;
10875         uint32_t _ptr_architecture;
10876         TALLOC_CTX *_mem_save_architecture_0;
10877         uint32_t _ptr_driver_path;
10878         TALLOC_CTX *_mem_save_driver_path_0;
10879         uint32_t _ptr_data_file;
10880         TALLOC_CTX *_mem_save_data_file_0;
10881         uint32_t _ptr_config_file;
10882         TALLOC_CTX *_mem_save_config_file_0;
10883         uint32_t _ptr_help_file;
10884         TALLOC_CTX *_mem_save_help_file_0;
10885         uint32_t _ptr_dependent_files;
10886         TALLOC_CTX *_mem_save_dependent_files_0;
10887         uint32_t _ptr_monitor_name;
10888         TALLOC_CTX *_mem_save_monitor_name_0;
10889         uint32_t _ptr_default_datatype;
10890         TALLOC_CTX *_mem_save_default_datatype_0;
10891         uint32_t _ptr_previous_names;
10892         TALLOC_CTX *_mem_save_previous_names_0;
10893         if (ndr_flags & NDR_SCALARS) {
10894                 NDR_CHECK(ndr_pull_align(ndr, 4));
10895                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10896                 {
10897                         uint32_t _flags_save_string = ndr->flags;
10898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10899                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10900                         if (_ptr_driver_name) {
10901                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10902                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10903                         } else {
10904                                 r->driver_name = NULL;
10905                         }
10906                         ndr->flags = _flags_save_string;
10907                 }
10908                 {
10909                         uint32_t _flags_save_string = ndr->flags;
10910                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10911                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10912                         if (_ptr_architecture) {
10913                                 NDR_PULL_ALLOC(ndr, r->architecture);
10914                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10915                         } else {
10916                                 r->architecture = NULL;
10917                         }
10918                         ndr->flags = _flags_save_string;
10919                 }
10920                 {
10921                         uint32_t _flags_save_string = ndr->flags;
10922                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10923                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10924                         if (_ptr_driver_path) {
10925                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10926                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10927                         } else {
10928                                 r->driver_path = NULL;
10929                         }
10930                         ndr->flags = _flags_save_string;
10931                 }
10932                 {
10933                         uint32_t _flags_save_string = ndr->flags;
10934                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10935                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10936                         if (_ptr_data_file) {
10937                                 NDR_PULL_ALLOC(ndr, r->data_file);
10938                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10939                         } else {
10940                                 r->data_file = NULL;
10941                         }
10942                         ndr->flags = _flags_save_string;
10943                 }
10944                 {
10945                         uint32_t _flags_save_string = ndr->flags;
10946                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10947                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10948                         if (_ptr_config_file) {
10949                                 NDR_PULL_ALLOC(ndr, r->config_file);
10950                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10951                         } else {
10952                                 r->config_file = NULL;
10953                         }
10954                         ndr->flags = _flags_save_string;
10955                 }
10956                 {
10957                         uint32_t _flags_save_string = ndr->flags;
10958                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10959                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10960                         if (_ptr_help_file) {
10961                                 NDR_PULL_ALLOC(ndr, r->help_file);
10962                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10963                         } else {
10964                                 r->help_file = NULL;
10965                         }
10966                         ndr->flags = _flags_save_string;
10967                 }
10968                 {
10969                         uint32_t _flags_save_string_array = ndr->flags;
10970                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10971                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10972                         if (_ptr_dependent_files) {
10973                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10974                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10975                         } else {
10976                                 r->dependent_files = NULL;
10977                         }
10978                         ndr->flags = _flags_save_string_array;
10979                 }
10980                 {
10981                         uint32_t _flags_save_string = ndr->flags;
10982                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10983                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10984                         if (_ptr_monitor_name) {
10985                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10986                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10987                         } else {
10988                                 r->monitor_name = NULL;
10989                         }
10990                         ndr->flags = _flags_save_string;
10991                 }
10992                 {
10993                         uint32_t _flags_save_string = ndr->flags;
10994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10995                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10996                         if (_ptr_default_datatype) {
10997                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10998                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10999                         } else {
11000                                 r->default_datatype = NULL;
11001                         }
11002                         ndr->flags = _flags_save_string;
11003                 }
11004                 {
11005                         uint32_t _flags_save_string_array = ndr->flags;
11006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11007                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11008                         if (_ptr_previous_names) {
11009                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11010                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11011                         } else {
11012                                 r->previous_names = NULL;
11013                         }
11014                         ndr->flags = _flags_save_string_array;
11015                 }
11016         }
11017         if (ndr_flags & NDR_BUFFERS) {
11018                 {
11019                         uint32_t _flags_save_string = ndr->flags;
11020                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11021                         if (r->driver_name) {
11022                                 uint32_t _relative_save_offset;
11023                                 _relative_save_offset = ndr->offset;
11024                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11025                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11026                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11027                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11028                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11029                                 ndr->offset = _relative_save_offset;
11030                         }
11031                         ndr->flags = _flags_save_string;
11032                 }
11033                 {
11034                         uint32_t _flags_save_string = ndr->flags;
11035                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11036                         if (r->architecture) {
11037                                 uint32_t _relative_save_offset;
11038                                 _relative_save_offset = ndr->offset;
11039                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11040                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11041                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11042                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11043                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11044                                 ndr->offset = _relative_save_offset;
11045                         }
11046                         ndr->flags = _flags_save_string;
11047                 }
11048                 {
11049                         uint32_t _flags_save_string = ndr->flags;
11050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11051                         if (r->driver_path) {
11052                                 uint32_t _relative_save_offset;
11053                                 _relative_save_offset = ndr->offset;
11054                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11055                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11056                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11057                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11058                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11059                                 ndr->offset = _relative_save_offset;
11060                         }
11061                         ndr->flags = _flags_save_string;
11062                 }
11063                 {
11064                         uint32_t _flags_save_string = ndr->flags;
11065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11066                         if (r->data_file) {
11067                                 uint32_t _relative_save_offset;
11068                                 _relative_save_offset = ndr->offset;
11069                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11070                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11071                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11072                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11073                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11074                                 ndr->offset = _relative_save_offset;
11075                         }
11076                         ndr->flags = _flags_save_string;
11077                 }
11078                 {
11079                         uint32_t _flags_save_string = ndr->flags;
11080                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11081                         if (r->config_file) {
11082                                 uint32_t _relative_save_offset;
11083                                 _relative_save_offset = ndr->offset;
11084                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11085                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11086                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11087                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11088                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11089                                 ndr->offset = _relative_save_offset;
11090                         }
11091                         ndr->flags = _flags_save_string;
11092                 }
11093                 {
11094                         uint32_t _flags_save_string = ndr->flags;
11095                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11096                         if (r->help_file) {
11097                                 uint32_t _relative_save_offset;
11098                                 _relative_save_offset = ndr->offset;
11099                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11100                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11101                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11102                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11103                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11104                                 ndr->offset = _relative_save_offset;
11105                         }
11106                         ndr->flags = _flags_save_string;
11107                 }
11108                 {
11109                         uint32_t _flags_save_string_array = ndr->flags;
11110                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11111                         if (r->dependent_files) {
11112                                 uint32_t _relative_save_offset;
11113                                 _relative_save_offset = ndr->offset;
11114                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11115                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11116                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11117                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11118                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11119                                 ndr->offset = _relative_save_offset;
11120                         }
11121                         ndr->flags = _flags_save_string_array;
11122                 }
11123                 {
11124                         uint32_t _flags_save_string = ndr->flags;
11125                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11126                         if (r->monitor_name) {
11127                                 uint32_t _relative_save_offset;
11128                                 _relative_save_offset = ndr->offset;
11129                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11130                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11131                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11132                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11133                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11134                                 ndr->offset = _relative_save_offset;
11135                         }
11136                         ndr->flags = _flags_save_string;
11137                 }
11138                 {
11139                         uint32_t _flags_save_string = ndr->flags;
11140                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11141                         if (r->default_datatype) {
11142                                 uint32_t _relative_save_offset;
11143                                 _relative_save_offset = ndr->offset;
11144                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11145                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11146                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11147                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11148                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11149                                 ndr->offset = _relative_save_offset;
11150                         }
11151                         ndr->flags = _flags_save_string;
11152                 }
11153                 {
11154                         uint32_t _flags_save_string_array = ndr->flags;
11155                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11156                         if (r->previous_names) {
11157                                 uint32_t _relative_save_offset;
11158                                 _relative_save_offset = ndr->offset;
11159                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11160                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11161                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11162                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11163                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11164                                 ndr->offset = _relative_save_offset;
11165                         }
11166                         ndr->flags = _flags_save_string_array;
11167                 }
11168         }
11169         return NDR_ERR_SUCCESS;
11170 }
11171
11172 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11173 {
11174         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11175         ndr->depth++;
11176         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11177         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11178         ndr->depth++;
11179         if (r->driver_name) {
11180                 ndr_print_string(ndr, "driver_name", r->driver_name);
11181         }
11182         ndr->depth--;
11183         ndr_print_ptr(ndr, "architecture", r->architecture);
11184         ndr->depth++;
11185         if (r->architecture) {
11186                 ndr_print_string(ndr, "architecture", r->architecture);
11187         }
11188         ndr->depth--;
11189         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11190         ndr->depth++;
11191         if (r->driver_path) {
11192                 ndr_print_string(ndr, "driver_path", r->driver_path);
11193         }
11194         ndr->depth--;
11195         ndr_print_ptr(ndr, "data_file", r->data_file);
11196         ndr->depth++;
11197         if (r->data_file) {
11198                 ndr_print_string(ndr, "data_file", r->data_file);
11199         }
11200         ndr->depth--;
11201         ndr_print_ptr(ndr, "config_file", r->config_file);
11202         ndr->depth++;
11203         if (r->config_file) {
11204                 ndr_print_string(ndr, "config_file", r->config_file);
11205         }
11206         ndr->depth--;
11207         ndr_print_ptr(ndr, "help_file", r->help_file);
11208         ndr->depth++;
11209         if (r->help_file) {
11210                 ndr_print_string(ndr, "help_file", r->help_file);
11211         }
11212         ndr->depth--;
11213         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11214         ndr->depth++;
11215         if (r->dependent_files) {
11216                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11217         }
11218         ndr->depth--;
11219         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11220         ndr->depth++;
11221         if (r->monitor_name) {
11222                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11223         }
11224         ndr->depth--;
11225         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11226         ndr->depth++;
11227         if (r->default_datatype) {
11228                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11229         }
11230         ndr->depth--;
11231         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11232         ndr->depth++;
11233         if (r->previous_names) {
11234                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11235         }
11236         ndr->depth--;
11237         ndr->depth--;
11238 }
11239
11240 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11241 {
11242         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11243 }
11244
11245 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11246 {
11247         if (ndr_flags & NDR_SCALARS) {
11248                 NDR_CHECK(ndr_push_align(ndr, 4));
11249                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11250                 {
11251                         uint32_t _flags_save_string = ndr->flags;
11252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11253                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11254                         ndr->flags = _flags_save_string;
11255                 }
11256                 {
11257                         uint32_t _flags_save_string = ndr->flags;
11258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11260                         ndr->flags = _flags_save_string;
11261                 }
11262                 {
11263                         uint32_t _flags_save_string = ndr->flags;
11264                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11265                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11266                         ndr->flags = _flags_save_string;
11267                 }
11268                 {
11269                         uint32_t _flags_save_string = ndr->flags;
11270                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11271                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11272                         ndr->flags = _flags_save_string;
11273                 }
11274                 {
11275                         uint32_t _flags_save_string = ndr->flags;
11276                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11277                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11278                         ndr->flags = _flags_save_string;
11279                 }
11280                 NDR_CHECK(ndr_push_spoolss_DriverAttributes(ndr, NDR_SCALARS, r->driver_attributes));
11281                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11283         }
11284         if (ndr_flags & NDR_BUFFERS) {
11285                 {
11286                         uint32_t _flags_save_string = ndr->flags;
11287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11288                         if (r->driver_name) {
11289                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11290                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11291                         }
11292                         ndr->flags = _flags_save_string;
11293                 }
11294                 {
11295                         uint32_t _flags_save_string = ndr->flags;
11296                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11297                         if (r->architecture) {
11298                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11299                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11300                         }
11301                         ndr->flags = _flags_save_string;
11302                 }
11303                 {
11304                         uint32_t _flags_save_string = ndr->flags;
11305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11306                         if (r->driver_path) {
11307                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11308                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11309                         }
11310                         ndr->flags = _flags_save_string;
11311                 }
11312                 {
11313                         uint32_t _flags_save_string = ndr->flags;
11314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11315                         if (r->data_file) {
11316                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11317                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11318                         }
11319                         ndr->flags = _flags_save_string;
11320                 }
11321                 {
11322                         uint32_t _flags_save_string = ndr->flags;
11323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11324                         if (r->config_file) {
11325                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11326                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11327                         }
11328                         ndr->flags = _flags_save_string;
11329                 }
11330         }
11331         return NDR_ERR_SUCCESS;
11332 }
11333
11334 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11335 {
11336         uint32_t _ptr_driver_name;
11337         TALLOC_CTX *_mem_save_driver_name_0;
11338         uint32_t _ptr_architecture;
11339         TALLOC_CTX *_mem_save_architecture_0;
11340         uint32_t _ptr_driver_path;
11341         TALLOC_CTX *_mem_save_driver_path_0;
11342         uint32_t _ptr_data_file;
11343         TALLOC_CTX *_mem_save_data_file_0;
11344         uint32_t _ptr_config_file;
11345         TALLOC_CTX *_mem_save_config_file_0;
11346         if (ndr_flags & NDR_SCALARS) {
11347                 NDR_CHECK(ndr_pull_align(ndr, 4));
11348                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11349                 {
11350                         uint32_t _flags_save_string = ndr->flags;
11351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11352                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11353                         if (_ptr_driver_name) {
11354                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11355                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11356                         } else {
11357                                 r->driver_name = NULL;
11358                         }
11359                         ndr->flags = _flags_save_string;
11360                 }
11361                 {
11362                         uint32_t _flags_save_string = ndr->flags;
11363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11364                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11365                         if (_ptr_architecture) {
11366                                 NDR_PULL_ALLOC(ndr, r->architecture);
11367                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11368                         } else {
11369                                 r->architecture = NULL;
11370                         }
11371                         ndr->flags = _flags_save_string;
11372                 }
11373                 {
11374                         uint32_t _flags_save_string = ndr->flags;
11375                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11376                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11377                         if (_ptr_driver_path) {
11378                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11379                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11380                         } else {
11381                                 r->driver_path = NULL;
11382                         }
11383                         ndr->flags = _flags_save_string;
11384                 }
11385                 {
11386                         uint32_t _flags_save_string = ndr->flags;
11387                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11388                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11389                         if (_ptr_data_file) {
11390                                 NDR_PULL_ALLOC(ndr, r->data_file);
11391                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11392                         } else {
11393                                 r->data_file = NULL;
11394                         }
11395                         ndr->flags = _flags_save_string;
11396                 }
11397                 {
11398                         uint32_t _flags_save_string = ndr->flags;
11399                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11400                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11401                         if (_ptr_config_file) {
11402                                 NDR_PULL_ALLOC(ndr, r->config_file);
11403                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11404                         } else {
11405                                 r->config_file = NULL;
11406                         }
11407                         ndr->flags = _flags_save_string;
11408                 }
11409                 NDR_CHECK(ndr_pull_spoolss_DriverAttributes(ndr, NDR_SCALARS, &r->driver_attributes));
11410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11412         }
11413         if (ndr_flags & NDR_BUFFERS) {
11414                 {
11415                         uint32_t _flags_save_string = ndr->flags;
11416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11417                         if (r->driver_name) {
11418                                 uint32_t _relative_save_offset;
11419                                 _relative_save_offset = ndr->offset;
11420                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11421                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11422                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11423                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11424                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11425                                 ndr->offset = _relative_save_offset;
11426                         }
11427                         ndr->flags = _flags_save_string;
11428                 }
11429                 {
11430                         uint32_t _flags_save_string = ndr->flags;
11431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11432                         if (r->architecture) {
11433                                 uint32_t _relative_save_offset;
11434                                 _relative_save_offset = ndr->offset;
11435                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11436                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11437                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11438                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11439                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11440                                 ndr->offset = _relative_save_offset;
11441                         }
11442                         ndr->flags = _flags_save_string;
11443                 }
11444                 {
11445                         uint32_t _flags_save_string = ndr->flags;
11446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11447                         if (r->driver_path) {
11448                                 uint32_t _relative_save_offset;
11449                                 _relative_save_offset = ndr->offset;
11450                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11451                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11452                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11453                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11454                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11455                                 ndr->offset = _relative_save_offset;
11456                         }
11457                         ndr->flags = _flags_save_string;
11458                 }
11459                 {
11460                         uint32_t _flags_save_string = ndr->flags;
11461                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11462                         if (r->data_file) {
11463                                 uint32_t _relative_save_offset;
11464                                 _relative_save_offset = ndr->offset;
11465                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11466                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11467                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11468                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11469                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11470                                 ndr->offset = _relative_save_offset;
11471                         }
11472                         ndr->flags = _flags_save_string;
11473                 }
11474                 {
11475                         uint32_t _flags_save_string = ndr->flags;
11476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11477                         if (r->config_file) {
11478                                 uint32_t _relative_save_offset;
11479                                 _relative_save_offset = ndr->offset;
11480                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11481                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11482                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11483                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11484                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11485                                 ndr->offset = _relative_save_offset;
11486                         }
11487                         ndr->flags = _flags_save_string;
11488                 }
11489         }
11490         return NDR_ERR_SUCCESS;
11491 }
11492
11493 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11494 {
11495         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11496         ndr->depth++;
11497         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11498         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11499         ndr->depth++;
11500         if (r->driver_name) {
11501                 ndr_print_string(ndr, "driver_name", r->driver_name);
11502         }
11503         ndr->depth--;
11504         ndr_print_ptr(ndr, "architecture", r->architecture);
11505         ndr->depth++;
11506         if (r->architecture) {
11507                 ndr_print_string(ndr, "architecture", r->architecture);
11508         }
11509         ndr->depth--;
11510         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11511         ndr->depth++;
11512         if (r->driver_path) {
11513                 ndr_print_string(ndr, "driver_path", r->driver_path);
11514         }
11515         ndr->depth--;
11516         ndr_print_ptr(ndr, "data_file", r->data_file);
11517         ndr->depth++;
11518         if (r->data_file) {
11519                 ndr_print_string(ndr, "data_file", r->data_file);
11520         }
11521         ndr->depth--;
11522         ndr_print_ptr(ndr, "config_file", r->config_file);
11523         ndr->depth++;
11524         if (r->config_file) {
11525                 ndr_print_string(ndr, "config_file", r->config_file);
11526         }
11527         ndr->depth--;
11528         ndr_print_spoolss_DriverAttributes(ndr, "driver_attributes", r->driver_attributes);
11529         ndr_print_uint32(ndr, "config_version", r->config_version);
11530         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11531         ndr->depth--;
11532 }
11533
11534 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11535 {
11536         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11537 }
11538
11539 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11540 {
11541         if (ndr_flags & NDR_SCALARS) {
11542                 NDR_CHECK(ndr_push_align(ndr, 8));
11543                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11544                 {
11545                         uint32_t _flags_save_string = ndr->flags;
11546                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11547                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11548                         ndr->flags = _flags_save_string;
11549                 }
11550                 {
11551                         uint32_t _flags_save_string = ndr->flags;
11552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11553                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11554                         ndr->flags = _flags_save_string;
11555                 }
11556                 {
11557                         uint32_t _flags_save_string = ndr->flags;
11558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11559                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11560                         ndr->flags = _flags_save_string;
11561                 }
11562                 {
11563                         uint32_t _flags_save_string = ndr->flags;
11564                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11565                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11566                         ndr->flags = _flags_save_string;
11567                 }
11568                 {
11569                         uint32_t _flags_save_string = ndr->flags;
11570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11571                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11572                         ndr->flags = _flags_save_string;
11573                 }
11574                 {
11575                         uint32_t _flags_save_string = ndr->flags;
11576                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11577                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11578                         ndr->flags = _flags_save_string;
11579                 }
11580                 {
11581                         uint32_t _flags_save_string_array = ndr->flags;
11582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11583                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11584                         ndr->flags = _flags_save_string_array;
11585                 }
11586                 {
11587                         uint32_t _flags_save_string = ndr->flags;
11588                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11589                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11590                         ndr->flags = _flags_save_string;
11591                 }
11592                 {
11593                         uint32_t _flags_save_string = ndr->flags;
11594                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11595                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11596                         ndr->flags = _flags_save_string;
11597                 }
11598                 {
11599                         uint32_t _flags_save_string_array = ndr->flags;
11600                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11601                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11602                         ndr->flags = _flags_save_string_array;
11603                 }
11604                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11605                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11606                 {
11607                         uint32_t _flags_save_string = ndr->flags;
11608                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11609                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11610                         ndr->flags = _flags_save_string;
11611                 }
11612                 {
11613                         uint32_t _flags_save_string = ndr->flags;
11614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11615                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11616                         ndr->flags = _flags_save_string;
11617                 }
11618                 {
11619                         uint32_t _flags_save_string = ndr->flags;
11620                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11621                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11622                         ndr->flags = _flags_save_string;
11623                 }
11624                 {
11625                         uint32_t _flags_save_string = ndr->flags;
11626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11627                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11628                         ndr->flags = _flags_save_string;
11629                 }
11630         }
11631         if (ndr_flags & NDR_BUFFERS) {
11632                 {
11633                         uint32_t _flags_save_string = ndr->flags;
11634                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11635                         if (r->driver_name) {
11636                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11637                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11638                         }
11639                         ndr->flags = _flags_save_string;
11640                 }
11641                 {
11642                         uint32_t _flags_save_string = ndr->flags;
11643                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11644                         if (r->architecture) {
11645                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11646                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11647                         }
11648                         ndr->flags = _flags_save_string;
11649                 }
11650                 {
11651                         uint32_t _flags_save_string = ndr->flags;
11652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11653                         if (r->driver_path) {
11654                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11655                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11656                         }
11657                         ndr->flags = _flags_save_string;
11658                 }
11659                 {
11660                         uint32_t _flags_save_string = ndr->flags;
11661                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11662                         if (r->data_file) {
11663                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11664                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11665                         }
11666                         ndr->flags = _flags_save_string;
11667                 }
11668                 {
11669                         uint32_t _flags_save_string = ndr->flags;
11670                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11671                         if (r->config_file) {
11672                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11673                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11674                         }
11675                         ndr->flags = _flags_save_string;
11676                 }
11677                 {
11678                         uint32_t _flags_save_string = ndr->flags;
11679                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11680                         if (r->help_file) {
11681                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11682                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11683                         }
11684                         ndr->flags = _flags_save_string;
11685                 }
11686                 {
11687                         uint32_t _flags_save_string_array = ndr->flags;
11688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11689                         if (r->dependent_files) {
11690                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11691                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11692                         }
11693                         ndr->flags = _flags_save_string_array;
11694                 }
11695                 {
11696                         uint32_t _flags_save_string = ndr->flags;
11697                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11698                         if (r->monitor_name) {
11699                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11700                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11701                         }
11702                         ndr->flags = _flags_save_string;
11703                 }
11704                 {
11705                         uint32_t _flags_save_string = ndr->flags;
11706                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11707                         if (r->default_datatype) {
11708                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11709                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11710                         }
11711                         ndr->flags = _flags_save_string;
11712                 }
11713                 {
11714                         uint32_t _flags_save_string_array = ndr->flags;
11715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11716                         if (r->previous_names) {
11717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11718                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11719                         }
11720                         ndr->flags = _flags_save_string_array;
11721                 }
11722                 {
11723                         uint32_t _flags_save_string = ndr->flags;
11724                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11725                         if (r->manufacturer_name) {
11726                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11727                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11728                         }
11729                         ndr->flags = _flags_save_string;
11730                 }
11731                 {
11732                         uint32_t _flags_save_string = ndr->flags;
11733                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11734                         if (r->manufacturer_url) {
11735                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11736                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11737                         }
11738                         ndr->flags = _flags_save_string;
11739                 }
11740                 {
11741                         uint32_t _flags_save_string = ndr->flags;
11742                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11743                         if (r->hardware_id) {
11744                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11745                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11746                         }
11747                         ndr->flags = _flags_save_string;
11748                 }
11749                 {
11750                         uint32_t _flags_save_string = ndr->flags;
11751                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11752                         if (r->provider) {
11753                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11754                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11755                         }
11756                         ndr->flags = _flags_save_string;
11757                 }
11758         }
11759         return NDR_ERR_SUCCESS;
11760 }
11761
11762 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11763 {
11764         uint32_t _ptr_driver_name;
11765         TALLOC_CTX *_mem_save_driver_name_0;
11766         uint32_t _ptr_architecture;
11767         TALLOC_CTX *_mem_save_architecture_0;
11768         uint32_t _ptr_driver_path;
11769         TALLOC_CTX *_mem_save_driver_path_0;
11770         uint32_t _ptr_data_file;
11771         TALLOC_CTX *_mem_save_data_file_0;
11772         uint32_t _ptr_config_file;
11773         TALLOC_CTX *_mem_save_config_file_0;
11774         uint32_t _ptr_help_file;
11775         TALLOC_CTX *_mem_save_help_file_0;
11776         uint32_t _ptr_dependent_files;
11777         TALLOC_CTX *_mem_save_dependent_files_0;
11778         uint32_t _ptr_monitor_name;
11779         TALLOC_CTX *_mem_save_monitor_name_0;
11780         uint32_t _ptr_default_datatype;
11781         TALLOC_CTX *_mem_save_default_datatype_0;
11782         uint32_t _ptr_previous_names;
11783         TALLOC_CTX *_mem_save_previous_names_0;
11784         uint32_t _ptr_manufacturer_name;
11785         TALLOC_CTX *_mem_save_manufacturer_name_0;
11786         uint32_t _ptr_manufacturer_url;
11787         TALLOC_CTX *_mem_save_manufacturer_url_0;
11788         uint32_t _ptr_hardware_id;
11789         TALLOC_CTX *_mem_save_hardware_id_0;
11790         uint32_t _ptr_provider;
11791         TALLOC_CTX *_mem_save_provider_0;
11792         if (ndr_flags & NDR_SCALARS) {
11793                 NDR_CHECK(ndr_pull_align(ndr, 8));
11794                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11795                 {
11796                         uint32_t _flags_save_string = ndr->flags;
11797                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11798                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11799                         if (_ptr_driver_name) {
11800                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11801                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11802                         } else {
11803                                 r->driver_name = NULL;
11804                         }
11805                         ndr->flags = _flags_save_string;
11806                 }
11807                 {
11808                         uint32_t _flags_save_string = ndr->flags;
11809                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11810                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11811                         if (_ptr_architecture) {
11812                                 NDR_PULL_ALLOC(ndr, r->architecture);
11813                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11814                         } else {
11815                                 r->architecture = NULL;
11816                         }
11817                         ndr->flags = _flags_save_string;
11818                 }
11819                 {
11820                         uint32_t _flags_save_string = ndr->flags;
11821                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11822                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11823                         if (_ptr_driver_path) {
11824                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11825                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11826                         } else {
11827                                 r->driver_path = NULL;
11828                         }
11829                         ndr->flags = _flags_save_string;
11830                 }
11831                 {
11832                         uint32_t _flags_save_string = ndr->flags;
11833                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11834                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11835                         if (_ptr_data_file) {
11836                                 NDR_PULL_ALLOC(ndr, r->data_file);
11837                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11838                         } else {
11839                                 r->data_file = NULL;
11840                         }
11841                         ndr->flags = _flags_save_string;
11842                 }
11843                 {
11844                         uint32_t _flags_save_string = ndr->flags;
11845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11847                         if (_ptr_config_file) {
11848                                 NDR_PULL_ALLOC(ndr, r->config_file);
11849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11850                         } else {
11851                                 r->config_file = NULL;
11852                         }
11853                         ndr->flags = _flags_save_string;
11854                 }
11855                 {
11856                         uint32_t _flags_save_string = ndr->flags;
11857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11858                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11859                         if (_ptr_help_file) {
11860                                 NDR_PULL_ALLOC(ndr, r->help_file);
11861                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11862                         } else {
11863                                 r->help_file = NULL;
11864                         }
11865                         ndr->flags = _flags_save_string;
11866                 }
11867                 {
11868                         uint32_t _flags_save_string_array = ndr->flags;
11869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11870                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11871                         if (_ptr_dependent_files) {
11872                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11873                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11874                         } else {
11875                                 r->dependent_files = NULL;
11876                         }
11877                         ndr->flags = _flags_save_string_array;
11878                 }
11879                 {
11880                         uint32_t _flags_save_string = ndr->flags;
11881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11883                         if (_ptr_monitor_name) {
11884                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11886                         } else {
11887                                 r->monitor_name = NULL;
11888                         }
11889                         ndr->flags = _flags_save_string;
11890                 }
11891                 {
11892                         uint32_t _flags_save_string = ndr->flags;
11893                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11894                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11895                         if (_ptr_default_datatype) {
11896                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11897                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11898                         } else {
11899                                 r->default_datatype = NULL;
11900                         }
11901                         ndr->flags = _flags_save_string;
11902                 }
11903                 {
11904                         uint32_t _flags_save_string_array = ndr->flags;
11905                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11906                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11907                         if (_ptr_previous_names) {
11908                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11909                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11910                         } else {
11911                                 r->previous_names = NULL;
11912                         }
11913                         ndr->flags = _flags_save_string_array;
11914                 }
11915                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11916                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11917                 {
11918                         uint32_t _flags_save_string = ndr->flags;
11919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11920                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11921                         if (_ptr_manufacturer_name) {
11922                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11923                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11924                         } else {
11925                                 r->manufacturer_name = NULL;
11926                         }
11927                         ndr->flags = _flags_save_string;
11928                 }
11929                 {
11930                         uint32_t _flags_save_string = ndr->flags;
11931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11932                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11933                         if (_ptr_manufacturer_url) {
11934                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11935                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11936                         } else {
11937                                 r->manufacturer_url = NULL;
11938                         }
11939                         ndr->flags = _flags_save_string;
11940                 }
11941                 {
11942                         uint32_t _flags_save_string = ndr->flags;
11943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11944                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11945                         if (_ptr_hardware_id) {
11946                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11947                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11948                         } else {
11949                                 r->hardware_id = NULL;
11950                         }
11951                         ndr->flags = _flags_save_string;
11952                 }
11953                 {
11954                         uint32_t _flags_save_string = ndr->flags;
11955                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11956                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11957                         if (_ptr_provider) {
11958                                 NDR_PULL_ALLOC(ndr, r->provider);
11959                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11960                         } else {
11961                                 r->provider = NULL;
11962                         }
11963                         ndr->flags = _flags_save_string;
11964                 }
11965         }
11966         if (ndr_flags & NDR_BUFFERS) {
11967                 {
11968                         uint32_t _flags_save_string = ndr->flags;
11969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11970                         if (r->driver_name) {
11971                                 uint32_t _relative_save_offset;
11972                                 _relative_save_offset = ndr->offset;
11973                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11974                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11975                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11976                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11977                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11978                                 ndr->offset = _relative_save_offset;
11979                         }
11980                         ndr->flags = _flags_save_string;
11981                 }
11982                 {
11983                         uint32_t _flags_save_string = ndr->flags;
11984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11985                         if (r->architecture) {
11986                                 uint32_t _relative_save_offset;
11987                                 _relative_save_offset = ndr->offset;
11988                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11989                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11990                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11991                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11992                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11993                                 ndr->offset = _relative_save_offset;
11994                         }
11995                         ndr->flags = _flags_save_string;
11996                 }
11997                 {
11998                         uint32_t _flags_save_string = ndr->flags;
11999                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12000                         if (r->driver_path) {
12001                                 uint32_t _relative_save_offset;
12002                                 _relative_save_offset = ndr->offset;
12003                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12004                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12005                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12006                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12007                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12008                                 ndr->offset = _relative_save_offset;
12009                         }
12010                         ndr->flags = _flags_save_string;
12011                 }
12012                 {
12013                         uint32_t _flags_save_string = ndr->flags;
12014                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12015                         if (r->data_file) {
12016                                 uint32_t _relative_save_offset;
12017                                 _relative_save_offset = ndr->offset;
12018                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12019                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12020                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12021                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12022                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12023                                 ndr->offset = _relative_save_offset;
12024                         }
12025                         ndr->flags = _flags_save_string;
12026                 }
12027                 {
12028                         uint32_t _flags_save_string = ndr->flags;
12029                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12030                         if (r->config_file) {
12031                                 uint32_t _relative_save_offset;
12032                                 _relative_save_offset = ndr->offset;
12033                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12034                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12035                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12036                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12037                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12038                                 ndr->offset = _relative_save_offset;
12039                         }
12040                         ndr->flags = _flags_save_string;
12041                 }
12042                 {
12043                         uint32_t _flags_save_string = ndr->flags;
12044                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12045                         if (r->help_file) {
12046                                 uint32_t _relative_save_offset;
12047                                 _relative_save_offset = ndr->offset;
12048                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12049                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12050                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12051                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12052                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12053                                 ndr->offset = _relative_save_offset;
12054                         }
12055                         ndr->flags = _flags_save_string;
12056                 }
12057                 {
12058                         uint32_t _flags_save_string_array = ndr->flags;
12059                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12060                         if (r->dependent_files) {
12061                                 uint32_t _relative_save_offset;
12062                                 _relative_save_offset = ndr->offset;
12063                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12064                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12065                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12066                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12067                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12068                                 ndr->offset = _relative_save_offset;
12069                         }
12070                         ndr->flags = _flags_save_string_array;
12071                 }
12072                 {
12073                         uint32_t _flags_save_string = ndr->flags;
12074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12075                         if (r->monitor_name) {
12076                                 uint32_t _relative_save_offset;
12077                                 _relative_save_offset = ndr->offset;
12078                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12079                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12080                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12081                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12082                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12083                                 ndr->offset = _relative_save_offset;
12084                         }
12085                         ndr->flags = _flags_save_string;
12086                 }
12087                 {
12088                         uint32_t _flags_save_string = ndr->flags;
12089                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12090                         if (r->default_datatype) {
12091                                 uint32_t _relative_save_offset;
12092                                 _relative_save_offset = ndr->offset;
12093                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12094                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12095                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12096                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12097                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12098                                 ndr->offset = _relative_save_offset;
12099                         }
12100                         ndr->flags = _flags_save_string;
12101                 }
12102                 {
12103                         uint32_t _flags_save_string_array = ndr->flags;
12104                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12105                         if (r->previous_names) {
12106                                 uint32_t _relative_save_offset;
12107                                 _relative_save_offset = ndr->offset;
12108                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12109                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12110                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12111                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12112                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12113                                 ndr->offset = _relative_save_offset;
12114                         }
12115                         ndr->flags = _flags_save_string_array;
12116                 }
12117                 {
12118                         uint32_t _flags_save_string = ndr->flags;
12119                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12120                         if (r->manufacturer_name) {
12121                                 uint32_t _relative_save_offset;
12122                                 _relative_save_offset = ndr->offset;
12123                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12124                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12125                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12126                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12127                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12128                                 ndr->offset = _relative_save_offset;
12129                         }
12130                         ndr->flags = _flags_save_string;
12131                 }
12132                 {
12133                         uint32_t _flags_save_string = ndr->flags;
12134                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12135                         if (r->manufacturer_url) {
12136                                 uint32_t _relative_save_offset;
12137                                 _relative_save_offset = ndr->offset;
12138                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12139                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12140                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12141                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12142                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12143                                 ndr->offset = _relative_save_offset;
12144                         }
12145                         ndr->flags = _flags_save_string;
12146                 }
12147                 {
12148                         uint32_t _flags_save_string = ndr->flags;
12149                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12150                         if (r->hardware_id) {
12151                                 uint32_t _relative_save_offset;
12152                                 _relative_save_offset = ndr->offset;
12153                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12154                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12155                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12156                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12157                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12158                                 ndr->offset = _relative_save_offset;
12159                         }
12160                         ndr->flags = _flags_save_string;
12161                 }
12162                 {
12163                         uint32_t _flags_save_string = ndr->flags;
12164                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12165                         if (r->provider) {
12166                                 uint32_t _relative_save_offset;
12167                                 _relative_save_offset = ndr->offset;
12168                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12169                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12170                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12171                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12172                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12173                                 ndr->offset = _relative_save_offset;
12174                         }
12175                         ndr->flags = _flags_save_string;
12176                 }
12177         }
12178         return NDR_ERR_SUCCESS;
12179 }
12180
12181 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12182 {
12183         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12184         ndr->depth++;
12185         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12186         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12187         ndr->depth++;
12188         if (r->driver_name) {
12189                 ndr_print_string(ndr, "driver_name", r->driver_name);
12190         }
12191         ndr->depth--;
12192         ndr_print_ptr(ndr, "architecture", r->architecture);
12193         ndr->depth++;
12194         if (r->architecture) {
12195                 ndr_print_string(ndr, "architecture", r->architecture);
12196         }
12197         ndr->depth--;
12198         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12199         ndr->depth++;
12200         if (r->driver_path) {
12201                 ndr_print_string(ndr, "driver_path", r->driver_path);
12202         }
12203         ndr->depth--;
12204         ndr_print_ptr(ndr, "data_file", r->data_file);
12205         ndr->depth++;
12206         if (r->data_file) {
12207                 ndr_print_string(ndr, "data_file", r->data_file);
12208         }
12209         ndr->depth--;
12210         ndr_print_ptr(ndr, "config_file", r->config_file);
12211         ndr->depth++;
12212         if (r->config_file) {
12213                 ndr_print_string(ndr, "config_file", r->config_file);
12214         }
12215         ndr->depth--;
12216         ndr_print_ptr(ndr, "help_file", r->help_file);
12217         ndr->depth++;
12218         if (r->help_file) {
12219                 ndr_print_string(ndr, "help_file", r->help_file);
12220         }
12221         ndr->depth--;
12222         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12223         ndr->depth++;
12224         if (r->dependent_files) {
12225                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12226         }
12227         ndr->depth--;
12228         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12229         ndr->depth++;
12230         if (r->monitor_name) {
12231                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12232         }
12233         ndr->depth--;
12234         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12235         ndr->depth++;
12236         if (r->default_datatype) {
12237                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12238         }
12239         ndr->depth--;
12240         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12241         ndr->depth++;
12242         if (r->previous_names) {
12243                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12244         }
12245         ndr->depth--;
12246         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12247         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12248         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12249         ndr->depth++;
12250         if (r->manufacturer_name) {
12251                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12252         }
12253         ndr->depth--;
12254         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12255         ndr->depth++;
12256         if (r->manufacturer_url) {
12257                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12258         }
12259         ndr->depth--;
12260         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12261         ndr->depth++;
12262         if (r->hardware_id) {
12263                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12264         }
12265         ndr->depth--;
12266         ndr_print_ptr(ndr, "provider", r->provider);
12267         ndr->depth++;
12268         if (r->provider) {
12269                 ndr_print_string(ndr, "provider", r->provider);
12270         }
12271         ndr->depth--;
12272         ndr->depth--;
12273 }
12274
12275 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12276 {
12277         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12278 }
12279
12280 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12281 {
12282         if (ndr_flags & NDR_SCALARS) {
12283                 NDR_CHECK(ndr_push_align(ndr, 8));
12284                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12285                 {
12286                         uint32_t _flags_save_string = ndr->flags;
12287                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12288                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12289                         ndr->flags = _flags_save_string;
12290                 }
12291                 {
12292                         uint32_t _flags_save_string = ndr->flags;
12293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12294                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12295                         ndr->flags = _flags_save_string;
12296                 }
12297                 {
12298                         uint32_t _flags_save_string = ndr->flags;
12299                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12300                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12301                         ndr->flags = _flags_save_string;
12302                 }
12303                 {
12304                         uint32_t _flags_save_string = ndr->flags;
12305                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12306                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12307                         ndr->flags = _flags_save_string;
12308                 }
12309                 {
12310                         uint32_t _flags_save_string = ndr->flags;
12311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12312                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12313                         ndr->flags = _flags_save_string;
12314                 }
12315                 {
12316                         uint32_t _flags_save_string = ndr->flags;
12317                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12318                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12319                         ndr->flags = _flags_save_string;
12320                 }
12321                 {
12322                         uint32_t _flags_save_string = ndr->flags;
12323                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12324                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12325                         ndr->flags = _flags_save_string;
12326                 }
12327                 {
12328                         uint32_t _flags_save_string = ndr->flags;
12329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12330                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12331                         ndr->flags = _flags_save_string;
12332                 }
12333                 {
12334                         uint32_t _flags_save_string_array = ndr->flags;
12335                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12336                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12337                         ndr->flags = _flags_save_string_array;
12338                 }
12339                 {
12340                         uint32_t _flags_save_string_array = ndr->flags;
12341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12342                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12343                         ndr->flags = _flags_save_string_array;
12344                 }
12345                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12346                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12347                 {
12348                         uint32_t _flags_save_string = ndr->flags;
12349                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12350                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12351                         ndr->flags = _flags_save_string;
12352                 }
12353                 {
12354                         uint32_t _flags_save_string = ndr->flags;
12355                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12356                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12357                         ndr->flags = _flags_save_string;
12358                 }
12359                 {
12360                         uint32_t _flags_save_string = ndr->flags;
12361                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12362                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12363                         ndr->flags = _flags_save_string;
12364                 }
12365                 {
12366                         uint32_t _flags_save_string = ndr->flags;
12367                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12368                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12369                         ndr->flags = _flags_save_string;
12370                 }
12371                 {
12372                         uint32_t _flags_save_string = ndr->flags;
12373                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12374                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12375                         ndr->flags = _flags_save_string;
12376                 }
12377                 {
12378                         uint32_t _flags_save_string = ndr->flags;
12379                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12380                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12381                         ndr->flags = _flags_save_string;
12382                 }
12383                 {
12384                         uint32_t _flags_save_string_array = ndr->flags;
12385                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12386                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12387                         ndr->flags = _flags_save_string_array;
12388                 }
12389                 {
12390                         uint32_t _flags_save_string = ndr->flags;
12391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12392                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12393                         ndr->flags = _flags_save_string;
12394                 }
12395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12396                 {
12397                         uint32_t _flags_save_string_array = ndr->flags;
12398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12399                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12400                         ndr->flags = _flags_save_string_array;
12401                 }
12402                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12403                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12404         }
12405         if (ndr_flags & NDR_BUFFERS) {
12406                 {
12407                         uint32_t _flags_save_string = ndr->flags;
12408                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12409                         if (r->driver_name) {
12410                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12411                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12412                         }
12413                         ndr->flags = _flags_save_string;
12414                 }
12415                 {
12416                         uint32_t _flags_save_string = ndr->flags;
12417                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12418                         if (r->architecture) {
12419                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12420                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12421                         }
12422                         ndr->flags = _flags_save_string;
12423                 }
12424                 {
12425                         uint32_t _flags_save_string = ndr->flags;
12426                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12427                         if (r->driver_path) {
12428                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12429                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12430                         }
12431                         ndr->flags = _flags_save_string;
12432                 }
12433                 {
12434                         uint32_t _flags_save_string = ndr->flags;
12435                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12436                         if (r->data_file) {
12437                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12438                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12439                         }
12440                         ndr->flags = _flags_save_string;
12441                 }
12442                 {
12443                         uint32_t _flags_save_string = ndr->flags;
12444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12445                         if (r->config_file) {
12446                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12447                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12448                         }
12449                         ndr->flags = _flags_save_string;
12450                 }
12451                 {
12452                         uint32_t _flags_save_string = ndr->flags;
12453                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12454                         if (r->help_file) {
12455                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12456                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12457                         }
12458                         ndr->flags = _flags_save_string;
12459                 }
12460                 {
12461                         uint32_t _flags_save_string = ndr->flags;
12462                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12463                         if (r->monitor_name) {
12464                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12465                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12466                         }
12467                         ndr->flags = _flags_save_string;
12468                 }
12469                 {
12470                         uint32_t _flags_save_string = ndr->flags;
12471                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12472                         if (r->default_datatype) {
12473                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12474                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12475                         }
12476                         ndr->flags = _flags_save_string;
12477                 }
12478                 {
12479                         uint32_t _flags_save_string_array = ndr->flags;
12480                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12481                         if (r->dependent_files) {
12482                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12483                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12484                         }
12485                         ndr->flags = _flags_save_string_array;
12486                 }
12487                 {
12488                         uint32_t _flags_save_string_array = ndr->flags;
12489                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12490                         if (r->previous_names) {
12491                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12492                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12493                         }
12494                         ndr->flags = _flags_save_string_array;
12495                 }
12496                 {
12497                         uint32_t _flags_save_string = ndr->flags;
12498                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12499                         if (r->manufacturer_name) {
12500                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12501                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12502                         }
12503                         ndr->flags = _flags_save_string;
12504                 }
12505                 {
12506                         uint32_t _flags_save_string = ndr->flags;
12507                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12508                         if (r->manufacturer_url) {
12509                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12510                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12511                         }
12512                         ndr->flags = _flags_save_string;
12513                 }
12514                 {
12515                         uint32_t _flags_save_string = ndr->flags;
12516                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12517                         if (r->hardware_id) {
12518                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12519                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12520                         }
12521                         ndr->flags = _flags_save_string;
12522                 }
12523                 {
12524                         uint32_t _flags_save_string = ndr->flags;
12525                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12526                         if (r->provider) {
12527                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12528                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12529                         }
12530                         ndr->flags = _flags_save_string;
12531                 }
12532                 {
12533                         uint32_t _flags_save_string = ndr->flags;
12534                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12535                         if (r->print_processor) {
12536                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12537                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12538                         }
12539                         ndr->flags = _flags_save_string;
12540                 }
12541                 {
12542                         uint32_t _flags_save_string = ndr->flags;
12543                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12544                         if (r->vendor_setup) {
12545                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12546                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12547                         }
12548                         ndr->flags = _flags_save_string;
12549                 }
12550                 {
12551                         uint32_t _flags_save_string_array = ndr->flags;
12552                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12553                         if (r->color_profiles) {
12554                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12555                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12556                         }
12557                         ndr->flags = _flags_save_string_array;
12558                 }
12559                 {
12560                         uint32_t _flags_save_string = ndr->flags;
12561                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12562                         if (r->inf_path) {
12563                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12564                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12565                         }
12566                         ndr->flags = _flags_save_string;
12567                 }
12568                 {
12569                         uint32_t _flags_save_string_array = ndr->flags;
12570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12571                         if (r->core_driver_dependencies) {
12572                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12573                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12574                         }
12575                         ndr->flags = _flags_save_string_array;
12576                 }
12577         }
12578         return NDR_ERR_SUCCESS;
12579 }
12580
12581 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12582 {
12583         uint32_t _ptr_driver_name;
12584         TALLOC_CTX *_mem_save_driver_name_0;
12585         uint32_t _ptr_architecture;
12586         TALLOC_CTX *_mem_save_architecture_0;
12587         uint32_t _ptr_driver_path;
12588         TALLOC_CTX *_mem_save_driver_path_0;
12589         uint32_t _ptr_data_file;
12590         TALLOC_CTX *_mem_save_data_file_0;
12591         uint32_t _ptr_config_file;
12592         TALLOC_CTX *_mem_save_config_file_0;
12593         uint32_t _ptr_help_file;
12594         TALLOC_CTX *_mem_save_help_file_0;
12595         uint32_t _ptr_monitor_name;
12596         TALLOC_CTX *_mem_save_monitor_name_0;
12597         uint32_t _ptr_default_datatype;
12598         TALLOC_CTX *_mem_save_default_datatype_0;
12599         uint32_t _ptr_dependent_files;
12600         TALLOC_CTX *_mem_save_dependent_files_0;
12601         uint32_t _ptr_previous_names;
12602         TALLOC_CTX *_mem_save_previous_names_0;
12603         uint32_t _ptr_manufacturer_name;
12604         TALLOC_CTX *_mem_save_manufacturer_name_0;
12605         uint32_t _ptr_manufacturer_url;
12606         TALLOC_CTX *_mem_save_manufacturer_url_0;
12607         uint32_t _ptr_hardware_id;
12608         TALLOC_CTX *_mem_save_hardware_id_0;
12609         uint32_t _ptr_provider;
12610         TALLOC_CTX *_mem_save_provider_0;
12611         uint32_t _ptr_print_processor;
12612         TALLOC_CTX *_mem_save_print_processor_0;
12613         uint32_t _ptr_vendor_setup;
12614         TALLOC_CTX *_mem_save_vendor_setup_0;
12615         uint32_t _ptr_color_profiles;
12616         TALLOC_CTX *_mem_save_color_profiles_0;
12617         uint32_t _ptr_inf_path;
12618         TALLOC_CTX *_mem_save_inf_path_0;
12619         uint32_t _ptr_core_driver_dependencies;
12620         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12621         if (ndr_flags & NDR_SCALARS) {
12622                 NDR_CHECK(ndr_pull_align(ndr, 8));
12623                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12624                 {
12625                         uint32_t _flags_save_string = ndr->flags;
12626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12627                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12628                         if (_ptr_driver_name) {
12629                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12630                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12631                         } else {
12632                                 r->driver_name = NULL;
12633                         }
12634                         ndr->flags = _flags_save_string;
12635                 }
12636                 {
12637                         uint32_t _flags_save_string = ndr->flags;
12638                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12639                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12640                         if (_ptr_architecture) {
12641                                 NDR_PULL_ALLOC(ndr, r->architecture);
12642                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12643                         } else {
12644                                 r->architecture = NULL;
12645                         }
12646                         ndr->flags = _flags_save_string;
12647                 }
12648                 {
12649                         uint32_t _flags_save_string = ndr->flags;
12650                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12651                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12652                         if (_ptr_driver_path) {
12653                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12654                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12655                         } else {
12656                                 r->driver_path = NULL;
12657                         }
12658                         ndr->flags = _flags_save_string;
12659                 }
12660                 {
12661                         uint32_t _flags_save_string = ndr->flags;
12662                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12663                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12664                         if (_ptr_data_file) {
12665                                 NDR_PULL_ALLOC(ndr, r->data_file);
12666                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12667                         } else {
12668                                 r->data_file = NULL;
12669                         }
12670                         ndr->flags = _flags_save_string;
12671                 }
12672                 {
12673                         uint32_t _flags_save_string = ndr->flags;
12674                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12675                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12676                         if (_ptr_config_file) {
12677                                 NDR_PULL_ALLOC(ndr, r->config_file);
12678                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12679                         } else {
12680                                 r->config_file = NULL;
12681                         }
12682                         ndr->flags = _flags_save_string;
12683                 }
12684                 {
12685                         uint32_t _flags_save_string = ndr->flags;
12686                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12687                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12688                         if (_ptr_help_file) {
12689                                 NDR_PULL_ALLOC(ndr, r->help_file);
12690                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12691                         } else {
12692                                 r->help_file = NULL;
12693                         }
12694                         ndr->flags = _flags_save_string;
12695                 }
12696                 {
12697                         uint32_t _flags_save_string = ndr->flags;
12698                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12699                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12700                         if (_ptr_monitor_name) {
12701                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12702                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12703                         } else {
12704                                 r->monitor_name = NULL;
12705                         }
12706                         ndr->flags = _flags_save_string;
12707                 }
12708                 {
12709                         uint32_t _flags_save_string = ndr->flags;
12710                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12711                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12712                         if (_ptr_default_datatype) {
12713                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12714                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12715                         } else {
12716                                 r->default_datatype = NULL;
12717                         }
12718                         ndr->flags = _flags_save_string;
12719                 }
12720                 {
12721                         uint32_t _flags_save_string_array = ndr->flags;
12722                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12723                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12724                         if (_ptr_dependent_files) {
12725                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12726                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12727                         } else {
12728                                 r->dependent_files = NULL;
12729                         }
12730                         ndr->flags = _flags_save_string_array;
12731                 }
12732                 {
12733                         uint32_t _flags_save_string_array = ndr->flags;
12734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12735                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12736                         if (_ptr_previous_names) {
12737                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12738                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12739                         } else {
12740                                 r->previous_names = NULL;
12741                         }
12742                         ndr->flags = _flags_save_string_array;
12743                 }
12744                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12745                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12746                 {
12747                         uint32_t _flags_save_string = ndr->flags;
12748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12749                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12750                         if (_ptr_manufacturer_name) {
12751                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12752                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12753                         } else {
12754                                 r->manufacturer_name = NULL;
12755                         }
12756                         ndr->flags = _flags_save_string;
12757                 }
12758                 {
12759                         uint32_t _flags_save_string = ndr->flags;
12760                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12761                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12762                         if (_ptr_manufacturer_url) {
12763                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12764                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12765                         } else {
12766                                 r->manufacturer_url = NULL;
12767                         }
12768                         ndr->flags = _flags_save_string;
12769                 }
12770                 {
12771                         uint32_t _flags_save_string = ndr->flags;
12772                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12773                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12774                         if (_ptr_hardware_id) {
12775                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12776                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12777                         } else {
12778                                 r->hardware_id = NULL;
12779                         }
12780                         ndr->flags = _flags_save_string;
12781                 }
12782                 {
12783                         uint32_t _flags_save_string = ndr->flags;
12784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12785                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12786                         if (_ptr_provider) {
12787                                 NDR_PULL_ALLOC(ndr, r->provider);
12788                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12789                         } else {
12790                                 r->provider = NULL;
12791                         }
12792                         ndr->flags = _flags_save_string;
12793                 }
12794                 {
12795                         uint32_t _flags_save_string = ndr->flags;
12796                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12797                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12798                         if (_ptr_print_processor) {
12799                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12800                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12801                         } else {
12802                                 r->print_processor = NULL;
12803                         }
12804                         ndr->flags = _flags_save_string;
12805                 }
12806                 {
12807                         uint32_t _flags_save_string = ndr->flags;
12808                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12809                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12810                         if (_ptr_vendor_setup) {
12811                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12812                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12813                         } else {
12814                                 r->vendor_setup = NULL;
12815                         }
12816                         ndr->flags = _flags_save_string;
12817                 }
12818                 {
12819                         uint32_t _flags_save_string_array = ndr->flags;
12820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12821                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12822                         if (_ptr_color_profiles) {
12823                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12824                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12825                         } else {
12826                                 r->color_profiles = NULL;
12827                         }
12828                         ndr->flags = _flags_save_string_array;
12829                 }
12830                 {
12831                         uint32_t _flags_save_string = ndr->flags;
12832                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12833                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12834                         if (_ptr_inf_path) {
12835                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12836                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12837                         } else {
12838                                 r->inf_path = NULL;
12839                         }
12840                         ndr->flags = _flags_save_string;
12841                 }
12842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12843                 {
12844                         uint32_t _flags_save_string_array = ndr->flags;
12845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12846                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12847                         if (_ptr_core_driver_dependencies) {
12848                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12849                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12850                         } else {
12851                                 r->core_driver_dependencies = NULL;
12852                         }
12853                         ndr->flags = _flags_save_string_array;
12854                 }
12855                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12856                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12857         }
12858         if (ndr_flags & NDR_BUFFERS) {
12859                 {
12860                         uint32_t _flags_save_string = ndr->flags;
12861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12862                         if (r->driver_name) {
12863                                 uint32_t _relative_save_offset;
12864                                 _relative_save_offset = ndr->offset;
12865                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12866                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12867                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12868                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12869                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12870                                 ndr->offset = _relative_save_offset;
12871                         }
12872                         ndr->flags = _flags_save_string;
12873                 }
12874                 {
12875                         uint32_t _flags_save_string = ndr->flags;
12876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12877                         if (r->architecture) {
12878                                 uint32_t _relative_save_offset;
12879                                 _relative_save_offset = ndr->offset;
12880                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12881                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12882                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12883                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12884                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12885                                 ndr->offset = _relative_save_offset;
12886                         }
12887                         ndr->flags = _flags_save_string;
12888                 }
12889                 {
12890                         uint32_t _flags_save_string = ndr->flags;
12891                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12892                         if (r->driver_path) {
12893                                 uint32_t _relative_save_offset;
12894                                 _relative_save_offset = ndr->offset;
12895                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12896                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12897                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12898                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12899                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12900                                 ndr->offset = _relative_save_offset;
12901                         }
12902                         ndr->flags = _flags_save_string;
12903                 }
12904                 {
12905                         uint32_t _flags_save_string = ndr->flags;
12906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12907                         if (r->data_file) {
12908                                 uint32_t _relative_save_offset;
12909                                 _relative_save_offset = ndr->offset;
12910                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12911                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12912                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12913                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12914                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12915                                 ndr->offset = _relative_save_offset;
12916                         }
12917                         ndr->flags = _flags_save_string;
12918                 }
12919                 {
12920                         uint32_t _flags_save_string = ndr->flags;
12921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12922                         if (r->config_file) {
12923                                 uint32_t _relative_save_offset;
12924                                 _relative_save_offset = ndr->offset;
12925                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12926                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12927                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12928                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12929                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12930                                 ndr->offset = _relative_save_offset;
12931                         }
12932                         ndr->flags = _flags_save_string;
12933                 }
12934                 {
12935                         uint32_t _flags_save_string = ndr->flags;
12936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12937                         if (r->help_file) {
12938                                 uint32_t _relative_save_offset;
12939                                 _relative_save_offset = ndr->offset;
12940                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12941                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12942                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12943                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12944                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12945                                 ndr->offset = _relative_save_offset;
12946                         }
12947                         ndr->flags = _flags_save_string;
12948                 }
12949                 {
12950                         uint32_t _flags_save_string = ndr->flags;
12951                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12952                         if (r->monitor_name) {
12953                                 uint32_t _relative_save_offset;
12954                                 _relative_save_offset = ndr->offset;
12955                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12956                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12957                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12958                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12959                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12960                                 ndr->offset = _relative_save_offset;
12961                         }
12962                         ndr->flags = _flags_save_string;
12963                 }
12964                 {
12965                         uint32_t _flags_save_string = ndr->flags;
12966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12967                         if (r->default_datatype) {
12968                                 uint32_t _relative_save_offset;
12969                                 _relative_save_offset = ndr->offset;
12970                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12971                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12972                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12973                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12974                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12975                                 ndr->offset = _relative_save_offset;
12976                         }
12977                         ndr->flags = _flags_save_string;
12978                 }
12979                 {
12980                         uint32_t _flags_save_string_array = ndr->flags;
12981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12982                         if (r->dependent_files) {
12983                                 uint32_t _relative_save_offset;
12984                                 _relative_save_offset = ndr->offset;
12985                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12986                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12987                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12988                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12989                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12990                                 ndr->offset = _relative_save_offset;
12991                         }
12992                         ndr->flags = _flags_save_string_array;
12993                 }
12994                 {
12995                         uint32_t _flags_save_string_array = ndr->flags;
12996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12997                         if (r->previous_names) {
12998                                 uint32_t _relative_save_offset;
12999                                 _relative_save_offset = ndr->offset;
13000                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
13001                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
13002                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
13003                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
13004                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
13005                                 ndr->offset = _relative_save_offset;
13006                         }
13007                         ndr->flags = _flags_save_string_array;
13008                 }
13009                 {
13010                         uint32_t _flags_save_string = ndr->flags;
13011                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13012                         if (r->manufacturer_name) {
13013                                 uint32_t _relative_save_offset;
13014                                 _relative_save_offset = ndr->offset;
13015                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
13016                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13017                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
13018                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
13019                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
13020                                 ndr->offset = _relative_save_offset;
13021                         }
13022                         ndr->flags = _flags_save_string;
13023                 }
13024                 {
13025                         uint32_t _flags_save_string = ndr->flags;
13026                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13027                         if (r->manufacturer_url) {
13028                                 uint32_t _relative_save_offset;
13029                                 _relative_save_offset = ndr->offset;
13030                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13031                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13032                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13033                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13034                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13035                                 ndr->offset = _relative_save_offset;
13036                         }
13037                         ndr->flags = _flags_save_string;
13038                 }
13039                 {
13040                         uint32_t _flags_save_string = ndr->flags;
13041                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13042                         if (r->hardware_id) {
13043                                 uint32_t _relative_save_offset;
13044                                 _relative_save_offset = ndr->offset;
13045                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13046                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13047                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13048                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13049                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13050                                 ndr->offset = _relative_save_offset;
13051                         }
13052                         ndr->flags = _flags_save_string;
13053                 }
13054                 {
13055                         uint32_t _flags_save_string = ndr->flags;
13056                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13057                         if (r->provider) {
13058                                 uint32_t _relative_save_offset;
13059                                 _relative_save_offset = ndr->offset;
13060                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13061                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13062                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13063                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13064                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13065                                 ndr->offset = _relative_save_offset;
13066                         }
13067                         ndr->flags = _flags_save_string;
13068                 }
13069                 {
13070                         uint32_t _flags_save_string = ndr->flags;
13071                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13072                         if (r->print_processor) {
13073                                 uint32_t _relative_save_offset;
13074                                 _relative_save_offset = ndr->offset;
13075                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13076                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13077                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13078                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13079                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13080                                 ndr->offset = _relative_save_offset;
13081                         }
13082                         ndr->flags = _flags_save_string;
13083                 }
13084                 {
13085                         uint32_t _flags_save_string = ndr->flags;
13086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13087                         if (r->vendor_setup) {
13088                                 uint32_t _relative_save_offset;
13089                                 _relative_save_offset = ndr->offset;
13090                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13091                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13092                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13093                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13094                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13095                                 ndr->offset = _relative_save_offset;
13096                         }
13097                         ndr->flags = _flags_save_string;
13098                 }
13099                 {
13100                         uint32_t _flags_save_string_array = ndr->flags;
13101                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13102                         if (r->color_profiles) {
13103                                 uint32_t _relative_save_offset;
13104                                 _relative_save_offset = ndr->offset;
13105                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13106                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13107                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13108                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13109                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13110                                 ndr->offset = _relative_save_offset;
13111                         }
13112                         ndr->flags = _flags_save_string_array;
13113                 }
13114                 {
13115                         uint32_t _flags_save_string = ndr->flags;
13116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13117                         if (r->inf_path) {
13118                                 uint32_t _relative_save_offset;
13119                                 _relative_save_offset = ndr->offset;
13120                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13121                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13122                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13123                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13124                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13125                                 ndr->offset = _relative_save_offset;
13126                         }
13127                         ndr->flags = _flags_save_string;
13128                 }
13129                 {
13130                         uint32_t _flags_save_string_array = ndr->flags;
13131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13132                         if (r->core_driver_dependencies) {
13133                                 uint32_t _relative_save_offset;
13134                                 _relative_save_offset = ndr->offset;
13135                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13136                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13137                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13138                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13139                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13140                                 ndr->offset = _relative_save_offset;
13141                         }
13142                         ndr->flags = _flags_save_string_array;
13143                 }
13144         }
13145         return NDR_ERR_SUCCESS;
13146 }
13147
13148 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13149 {
13150         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13151         ndr->depth++;
13152         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13153         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13154         ndr->depth++;
13155         if (r->driver_name) {
13156                 ndr_print_string(ndr, "driver_name", r->driver_name);
13157         }
13158         ndr->depth--;
13159         ndr_print_ptr(ndr, "architecture", r->architecture);
13160         ndr->depth++;
13161         if (r->architecture) {
13162                 ndr_print_string(ndr, "architecture", r->architecture);
13163         }
13164         ndr->depth--;
13165         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13166         ndr->depth++;
13167         if (r->driver_path) {
13168                 ndr_print_string(ndr, "driver_path", r->driver_path);
13169         }
13170         ndr->depth--;
13171         ndr_print_ptr(ndr, "data_file", r->data_file);
13172         ndr->depth++;
13173         if (r->data_file) {
13174                 ndr_print_string(ndr, "data_file", r->data_file);
13175         }
13176         ndr->depth--;
13177         ndr_print_ptr(ndr, "config_file", r->config_file);
13178         ndr->depth++;
13179         if (r->config_file) {
13180                 ndr_print_string(ndr, "config_file", r->config_file);
13181         }
13182         ndr->depth--;
13183         ndr_print_ptr(ndr, "help_file", r->help_file);
13184         ndr->depth++;
13185         if (r->help_file) {
13186                 ndr_print_string(ndr, "help_file", r->help_file);
13187         }
13188         ndr->depth--;
13189         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13190         ndr->depth++;
13191         if (r->monitor_name) {
13192                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13193         }
13194         ndr->depth--;
13195         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13196         ndr->depth++;
13197         if (r->default_datatype) {
13198                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13199         }
13200         ndr->depth--;
13201         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13202         ndr->depth++;
13203         if (r->dependent_files) {
13204                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13205         }
13206         ndr->depth--;
13207         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13208         ndr->depth++;
13209         if (r->previous_names) {
13210                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13211         }
13212         ndr->depth--;
13213         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13214         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13215         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13216         ndr->depth++;
13217         if (r->manufacturer_name) {
13218                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13219         }
13220         ndr->depth--;
13221         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13222         ndr->depth++;
13223         if (r->manufacturer_url) {
13224                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13225         }
13226         ndr->depth--;
13227         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13228         ndr->depth++;
13229         if (r->hardware_id) {
13230                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13231         }
13232         ndr->depth--;
13233         ndr_print_ptr(ndr, "provider", r->provider);
13234         ndr->depth++;
13235         if (r->provider) {
13236                 ndr_print_string(ndr, "provider", r->provider);
13237         }
13238         ndr->depth--;
13239         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13240         ndr->depth++;
13241         if (r->print_processor) {
13242                 ndr_print_string(ndr, "print_processor", r->print_processor);
13243         }
13244         ndr->depth--;
13245         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13246         ndr->depth++;
13247         if (r->vendor_setup) {
13248                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13249         }
13250         ndr->depth--;
13251         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13252         ndr->depth++;
13253         if (r->color_profiles) {
13254                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13255         }
13256         ndr->depth--;
13257         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13258         ndr->depth++;
13259         if (r->inf_path) {
13260                 ndr_print_string(ndr, "inf_path", r->inf_path);
13261         }
13262         ndr->depth--;
13263         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13264         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13265         ndr->depth++;
13266         if (r->core_driver_dependencies) {
13267                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13268         }
13269         ndr->depth--;
13270         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13271         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13272         ndr->depth--;
13273 }
13274
13275 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13276 {
13277         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13278 }
13279
13280 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13281 {
13282         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13283         return NDR_ERR_SUCCESS;
13284 }
13285
13286 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13287 {
13288         uint32_t v;
13289         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13290         *r = v;
13291         return NDR_ERR_SUCCESS;
13292 }
13293
13294 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13295 {
13296         const char *val = NULL;
13297
13298         switch (r) {
13299                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13300                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13301                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13302                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13303                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13304         }
13305         ndr_print_enum(ndr, name, "ENUM", val, r);
13306 }
13307
13308 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13309 {
13310         if (ndr_flags & NDR_SCALARS) {
13311                 NDR_CHECK(ndr_push_align(ndr, 4));
13312                 {
13313                         uint32_t _flags_save_string = ndr->flags;
13314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13315                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13316                         ndr->flags = _flags_save_string;
13317                 }
13318                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13320         }
13321         if (ndr_flags & NDR_BUFFERS) {
13322                 {
13323                         uint32_t _flags_save_string = ndr->flags;
13324                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13325                         if (r->file_name) {
13326                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13327                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13328                         }
13329                         ndr->flags = _flags_save_string;
13330                 }
13331         }
13332         return NDR_ERR_SUCCESS;
13333 }
13334
13335 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13336 {
13337         uint32_t _ptr_file_name;
13338         TALLOC_CTX *_mem_save_file_name_0;
13339         if (ndr_flags & NDR_SCALARS) {
13340                 NDR_CHECK(ndr_pull_align(ndr, 4));
13341                 {
13342                         uint32_t _flags_save_string = ndr->flags;
13343                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13344                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13345                         if (_ptr_file_name) {
13346                                 NDR_PULL_ALLOC(ndr, r->file_name);
13347                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13348                         } else {
13349                                 r->file_name = NULL;
13350                         }
13351                         ndr->flags = _flags_save_string;
13352                 }
13353                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13354                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13355         }
13356         if (ndr_flags & NDR_BUFFERS) {
13357                 {
13358                         uint32_t _flags_save_string = ndr->flags;
13359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13360                         if (r->file_name) {
13361                                 uint32_t _relative_save_offset;
13362                                 _relative_save_offset = ndr->offset;
13363                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13364                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13365                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13366                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13367                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13368                                 ndr->offset = _relative_save_offset;
13369                         }
13370                         ndr->flags = _flags_save_string;
13371                 }
13372         }
13373         return NDR_ERR_SUCCESS;
13374 }
13375
13376 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13377 {
13378         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13379         ndr->depth++;
13380         ndr_print_ptr(ndr, "file_name", r->file_name);
13381         ndr->depth++;
13382         if (r->file_name) {
13383                 ndr_print_string(ndr, "file_name", r->file_name);
13384         }
13385         ndr->depth--;
13386         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13387         ndr_print_uint32(ndr, "file_version", r->file_version);
13388         ndr->depth--;
13389 }
13390
13391 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13392 {
13393         uint32_t cntr_file_info_1;
13394         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13395         ndr->depth++;
13396         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13397         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13398         ndr->depth++;
13399         if (r->driver_name) {
13400                 ndr_print_string(ndr, "driver_name", r->driver_name);
13401         }
13402         ndr->depth--;
13403         ndr_print_ptr(ndr, "architecture", r->architecture);
13404         ndr->depth++;
13405         if (r->architecture) {
13406                 ndr_print_string(ndr, "architecture", r->architecture);
13407         }
13408         ndr->depth--;
13409         ndr_print_ptr(ndr, "file_info", r->file_info);
13410         ndr->depth++;
13411         if (r->file_info) {
13412                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13413                 ndr->depth++;
13414                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13415                         char *idx_1=NULL;
13416                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13417                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13418                                 free(idx_1);
13419                         }
13420                 }
13421                 ndr->depth--;
13422         }
13423         ndr->depth--;
13424         ndr_print_uint32(ndr, "file_count", r->file_count);
13425         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13426         ndr->depth++;
13427         if (r->monitor_name) {
13428                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13429         }
13430         ndr->depth--;
13431         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13432         ndr->depth++;
13433         if (r->default_datatype) {
13434                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13435         }
13436         ndr->depth--;
13437         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13438         ndr->depth++;
13439         if (r->previous_names) {
13440                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13441         }
13442         ndr->depth--;
13443         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13444         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13445         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13446         ndr->depth++;
13447         if (r->manufacturer_name) {
13448                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13449         }
13450         ndr->depth--;
13451         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13452         ndr->depth++;
13453         if (r->manufacturer_url) {
13454                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13455         }
13456         ndr->depth--;
13457         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13458         ndr->depth++;
13459         if (r->hardware_id) {
13460                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13461         }
13462         ndr->depth--;
13463         ndr_print_ptr(ndr, "provider", r->provider);
13464         ndr->depth++;
13465         if (r->provider) {
13466                 ndr_print_string(ndr, "provider", r->provider);
13467         }
13468         ndr->depth--;
13469         ndr->depth--;
13470 }
13471
13472 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13473 {
13474         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13475 }
13476
13477 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13478 {
13479         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13480         if (ndr_flags & NDR_SCALARS) {
13481                 int level = ndr_push_get_switch_value(ndr, r);
13482                 switch (level) {
13483                         case 1: {
13484                                 NDR_CHECK(ndr_push_align(ndr, 4));
13485                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13486                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13487                         break; }
13488
13489                         case 2: {
13490                                 NDR_CHECK(ndr_push_align(ndr, 4));
13491                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13492                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13493                         break; }
13494
13495                         case 3: {
13496                                 NDR_CHECK(ndr_push_align(ndr, 4));
13497                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13498                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13499                         break; }
13500
13501                         case 4: {
13502                                 NDR_CHECK(ndr_push_align(ndr, 4));
13503                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13504                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13505                         break; }
13506
13507                         case 5: {
13508                                 NDR_CHECK(ndr_push_align(ndr, 4));
13509                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13510                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13511                         break; }
13512
13513                         case 6: {
13514                                 NDR_CHECK(ndr_push_align(ndr, 8));
13515                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13516                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13517                         break; }
13518
13519                         case 8: {
13520                                 NDR_CHECK(ndr_push_align(ndr, 8));
13521                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13522                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13523                         break; }
13524
13525                         case 101: {
13526                                 NDR_CHECK(ndr_push_align(ndr, 8));
13527                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13528                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13529                         break; }
13530
13531                         default: {
13532                         break; }
13533
13534                 }
13535         }
13536         if (ndr_flags & NDR_BUFFERS) {
13537                 int level = ndr_push_get_switch_value(ndr, r);
13538                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13539                 switch (level) {
13540                         case 1:
13541                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13542                         break;
13543
13544                         case 2:
13545                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13546                         break;
13547
13548                         case 3:
13549                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13550                         break;
13551
13552                         case 4:
13553                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13554                         break;
13555
13556                         case 5:
13557                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13558                         break;
13559
13560                         case 6:
13561                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13562                         break;
13563
13564                         case 8:
13565                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13566                         break;
13567
13568                         case 101:
13569                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13570                         break;
13571
13572                         default:
13573                         break;
13574
13575                 }
13576         }
13577         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13578         return NDR_ERR_SUCCESS;
13579 }
13580
13581 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13582 {
13583         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13584         int level;
13585         level = ndr_pull_get_switch_value(ndr, r);
13586         if (ndr_flags & NDR_SCALARS) {
13587                 switch (level) {
13588                         case 1: {
13589                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13590                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13591                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13592                         break; }
13593
13594                         case 2: {
13595                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13596                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13597                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13598                         break; }
13599
13600                         case 3: {
13601                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13602                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13603                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13604                         break; }
13605
13606                         case 4: {
13607                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13608                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13609                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13610                         break; }
13611
13612                         case 5: {
13613                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13614                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13615                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13616                         break; }
13617
13618                         case 6: {
13619                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13620                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13621                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13622                         break; }
13623
13624                         case 8: {
13625                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13626                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13627                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13628                         break; }
13629
13630                         case 101: {
13631                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13632                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13633                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13634                         break; }
13635
13636                         default: {
13637                         break; }
13638
13639                 }
13640         }
13641         if (ndr_flags & NDR_BUFFERS) {
13642                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13643                 switch (level) {
13644                         case 1:
13645                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13646                         break;
13647
13648                         case 2:
13649                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13650                         break;
13651
13652                         case 3:
13653                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13654                         break;
13655
13656                         case 4:
13657                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13658                         break;
13659
13660                         case 5:
13661                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13662                         break;
13663
13664                         case 6:
13665                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13666                         break;
13667
13668                         case 8:
13669                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13670                         break;
13671
13672                         case 101:
13673                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13674                         break;
13675
13676                         default:
13677                         break;
13678
13679                 }
13680         }
13681         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13682         return NDR_ERR_SUCCESS;
13683 }
13684
13685 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13686 {
13687         int level;
13688         level = ndr_print_get_switch_value(ndr, r);
13689         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13690         switch (level) {
13691                 case 1:
13692                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13693                 break;
13694
13695                 case 2:
13696                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13697                 break;
13698
13699                 case 3:
13700                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13701                 break;
13702
13703                 case 4:
13704                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13705                 break;
13706
13707                 case 5:
13708                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13709                 break;
13710
13711                 case 6:
13712                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13713                 break;
13714
13715                 case 8:
13716                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13717                 break;
13718
13719                 case 101:
13720                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13721                 break;
13722
13723                 default:
13724                 break;
13725
13726         }
13727 }
13728
13729 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13730 {
13731         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
13732 }
13733
13734 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13735 {
13736         if (ndr_flags & NDR_SCALARS) {
13737                 NDR_CHECK(ndr_push_align(ndr, 4));
13738                 {
13739                         uint32_t _flags_save_string = ndr->flags;
13740                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13741                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13742                         ndr->flags = _flags_save_string;
13743                 }
13744         }
13745         if (ndr_flags & NDR_BUFFERS) {
13746         }
13747         return NDR_ERR_SUCCESS;
13748 }
13749
13750 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13751 {
13752         if (ndr_flags & NDR_SCALARS) {
13753                 NDR_CHECK(ndr_pull_align(ndr, 4));
13754                 {
13755                         uint32_t _flags_save_string = ndr->flags;
13756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13757                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13758                         ndr->flags = _flags_save_string;
13759                 }
13760         }
13761         if (ndr_flags & NDR_BUFFERS) {
13762         }
13763         return NDR_ERR_SUCCESS;
13764 }
13765
13766 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13767 {
13768         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13769         ndr->depth++;
13770         ndr_print_string(ndr, "directory_name", r->directory_name);
13771         ndr->depth--;
13772 }
13773
13774 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13775 {
13776         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13777 }
13778
13779 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13780 {
13781         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13782         if (ndr_flags & NDR_SCALARS) {
13783                 int level = ndr_push_get_switch_value(ndr, r);
13784                 switch (level) {
13785                         case 1: {
13786                                 NDR_CHECK(ndr_push_align(ndr, 4));
13787                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13788                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13789                         break; }
13790
13791                         default: {
13792                                 NDR_CHECK(ndr_push_align(ndr, 4));
13793                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13794                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13795                         break; }
13796
13797                 }
13798         }
13799         if (ndr_flags & NDR_BUFFERS) {
13800                 int level = ndr_push_get_switch_value(ndr, r);
13801                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13802                 switch (level) {
13803                         case 1:
13804                         break;
13805
13806                         default:
13807                         break;
13808
13809                 }
13810         }
13811         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13812         return NDR_ERR_SUCCESS;
13813 }
13814
13815 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13816 {
13817         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13818         int level;
13819         level = ndr_pull_get_switch_value(ndr, r);
13820         if (ndr_flags & NDR_SCALARS) {
13821                 switch (level) {
13822                         case 1: {
13823                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13824                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13825                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13826                         break; }
13827
13828                         default: {
13829                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13830                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13831                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13832                         break; }
13833
13834                 }
13835         }
13836         if (ndr_flags & NDR_BUFFERS) {
13837                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13838                 switch (level) {
13839                         case 1:
13840                         break;
13841
13842                         default:
13843                         break;
13844
13845                 }
13846         }
13847         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13848         return NDR_ERR_SUCCESS;
13849 }
13850
13851 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13852 {
13853         int level;
13854         level = ndr_print_get_switch_value(ndr, r);
13855         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13856         switch (level) {
13857                 case 1:
13858                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13859                 break;
13860
13861                 default:
13862                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13863                 break;
13864
13865         }
13866 }
13867
13868 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13869 {
13870         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13871 }
13872
13873 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13874 {
13875         if (ndr_flags & NDR_SCALARS) {
13876                 NDR_CHECK(ndr_push_align(ndr, 4));
13877                 {
13878                         uint32_t _flags_save_string = ndr->flags;
13879                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13880                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13881                         ndr->flags = _flags_save_string;
13882                 }
13883         }
13884         if (ndr_flags & NDR_BUFFERS) {
13885                 {
13886                         uint32_t _flags_save_string = ndr->flags;
13887                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13888                         if (r->print_processor_name) {
13889                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13890                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13891                         }
13892                         ndr->flags = _flags_save_string;
13893                 }
13894         }
13895         return NDR_ERR_SUCCESS;
13896 }
13897
13898 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13899 {
13900         uint32_t _ptr_print_processor_name;
13901         TALLOC_CTX *_mem_save_print_processor_name_0;
13902         if (ndr_flags & NDR_SCALARS) {
13903                 NDR_CHECK(ndr_pull_align(ndr, 4));
13904                 {
13905                         uint32_t _flags_save_string = ndr->flags;
13906                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13907                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13908                         if (_ptr_print_processor_name) {
13909                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13910                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13911                         } else {
13912                                 r->print_processor_name = NULL;
13913                         }
13914                         ndr->flags = _flags_save_string;
13915                 }
13916         }
13917         if (ndr_flags & NDR_BUFFERS) {
13918                 {
13919                         uint32_t _flags_save_string = ndr->flags;
13920                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13921                         if (r->print_processor_name) {
13922                                 uint32_t _relative_save_offset;
13923                                 _relative_save_offset = ndr->offset;
13924                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13925                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13926                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13927                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13928                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13929                                 ndr->offset = _relative_save_offset;
13930                         }
13931                         ndr->flags = _flags_save_string;
13932                 }
13933         }
13934         return NDR_ERR_SUCCESS;
13935 }
13936
13937 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13938 {
13939         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13940         ndr->depth++;
13941         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13942         ndr->depth++;
13943         if (r->print_processor_name) {
13944                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13945         }
13946         ndr->depth--;
13947         ndr->depth--;
13948 }
13949
13950 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13951 {
13952         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13953 }
13954
13955 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13956 {
13957         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13958         if (ndr_flags & NDR_SCALARS) {
13959                 int level = ndr_push_get_switch_value(ndr, r);
13960                 switch (level) {
13961                         case 1: {
13962                                 NDR_CHECK(ndr_push_align(ndr, 4));
13963                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13964                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13965                         break; }
13966
13967                         default: {
13968                         break; }
13969
13970                 }
13971         }
13972         if (ndr_flags & NDR_BUFFERS) {
13973                 int level = ndr_push_get_switch_value(ndr, r);
13974                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13975                 switch (level) {
13976                         case 1:
13977                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13978                         break;
13979
13980                         default:
13981                         break;
13982
13983                 }
13984         }
13985         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13986         return NDR_ERR_SUCCESS;
13987 }
13988
13989 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13990 {
13991         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13992         int level;
13993         level = ndr_pull_get_switch_value(ndr, r);
13994         if (ndr_flags & NDR_SCALARS) {
13995                 switch (level) {
13996                         case 1: {
13997                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13998                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13999                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
14000                         break; }
14001
14002                         default: {
14003                         break; }
14004
14005                 }
14006         }
14007         if (ndr_flags & NDR_BUFFERS) {
14008                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14009                 switch (level) {
14010                         case 1:
14011                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
14012                         break;
14013
14014                         default:
14015                         break;
14016
14017                 }
14018         }
14019         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14020         return NDR_ERR_SUCCESS;
14021 }
14022
14023 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14024 {
14025         int level;
14026         level = ndr_print_get_switch_value(ndr, r);
14027         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14028         switch (level) {
14029                 case 1:
14030                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14031                 break;
14032
14033                 default:
14034                 break;
14035
14036         }
14037 }
14038
14039 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14040 {
14041         if (ndr_flags & NDR_SCALARS) {
14042                 NDR_CHECK(ndr_push_align(ndr, 4));
14043                 {
14044                         uint32_t _flags_save_string = ndr->flags;
14045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14046                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14047                         ndr->flags = _flags_save_string;
14048                 }
14049         }
14050         if (ndr_flags & NDR_BUFFERS) {
14051         }
14052         return NDR_ERR_SUCCESS;
14053 }
14054
14055 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14056 {
14057         if (ndr_flags & NDR_SCALARS) {
14058                 NDR_CHECK(ndr_pull_align(ndr, 4));
14059                 {
14060                         uint32_t _flags_save_string = ndr->flags;
14061                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14062                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14063                         ndr->flags = _flags_save_string;
14064                 }
14065         }
14066         if (ndr_flags & NDR_BUFFERS) {
14067         }
14068         return NDR_ERR_SUCCESS;
14069 }
14070
14071 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14072 {
14073         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14074         ndr->depth++;
14075         ndr_print_string(ndr, "directory_name", r->directory_name);
14076         ndr->depth--;
14077 }
14078
14079 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14080 {
14081         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14082 }
14083
14084 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14085 {
14086         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14087         if (ndr_flags & NDR_SCALARS) {
14088                 int level = ndr_push_get_switch_value(ndr, r);
14089                 switch (level) {
14090                         case 1: {
14091                                 NDR_CHECK(ndr_push_align(ndr, 4));
14092                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14093                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14094                         break; }
14095
14096                         default: {
14097                                 NDR_CHECK(ndr_push_align(ndr, 4));
14098                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14099                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14100                         break; }
14101
14102                 }
14103         }
14104         if (ndr_flags & NDR_BUFFERS) {
14105                 int level = ndr_push_get_switch_value(ndr, r);
14106                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14107                 switch (level) {
14108                         case 1:
14109                         break;
14110
14111                         default:
14112                         break;
14113
14114                 }
14115         }
14116         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14117         return NDR_ERR_SUCCESS;
14118 }
14119
14120 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14121 {
14122         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14123         int level;
14124         level = ndr_pull_get_switch_value(ndr, r);
14125         if (ndr_flags & NDR_SCALARS) {
14126                 switch (level) {
14127                         case 1: {
14128                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14129                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14130                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14131                         break; }
14132
14133                         default: {
14134                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14135                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14136                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14137                         break; }
14138
14139                 }
14140         }
14141         if (ndr_flags & NDR_BUFFERS) {
14142                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14143                 switch (level) {
14144                         case 1:
14145                         break;
14146
14147                         default:
14148                         break;
14149
14150                 }
14151         }
14152         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14153         return NDR_ERR_SUCCESS;
14154 }
14155
14156 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14157 {
14158         int level;
14159         level = ndr_print_get_switch_value(ndr, r);
14160         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14161         switch (level) {
14162                 case 1:
14163                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14164                 break;
14165
14166                 default:
14167                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14168                 break;
14169
14170         }
14171 }
14172
14173 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14174 {
14175         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14176 }
14177
14178 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14179 {
14180         if (ndr_flags & NDR_SCALARS) {
14181                 NDR_CHECK(ndr_push_align(ndr, 4));
14182                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14183                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14184                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14185         }
14186         if (ndr_flags & NDR_BUFFERS) {
14187                 if (r->document_name) {
14188                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14189                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14190                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14191                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14192                 }
14193                 if (r->output_file) {
14194                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14195                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14196                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14197                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14198                 }
14199                 if (r->datatype) {
14200                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14201                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14202                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14203                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14204                 }
14205         }
14206         return NDR_ERR_SUCCESS;
14207 }
14208
14209 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14210 {
14211         uint32_t _ptr_document_name;
14212         TALLOC_CTX *_mem_save_document_name_0;
14213         uint32_t _ptr_output_file;
14214         TALLOC_CTX *_mem_save_output_file_0;
14215         uint32_t _ptr_datatype;
14216         TALLOC_CTX *_mem_save_datatype_0;
14217         if (ndr_flags & NDR_SCALARS) {
14218                 NDR_CHECK(ndr_pull_align(ndr, 4));
14219                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14220                 if (_ptr_document_name) {
14221                         NDR_PULL_ALLOC(ndr, r->document_name);
14222                 } else {
14223                         r->document_name = NULL;
14224                 }
14225                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14226                 if (_ptr_output_file) {
14227                         NDR_PULL_ALLOC(ndr, r->output_file);
14228                 } else {
14229                         r->output_file = NULL;
14230                 }
14231                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14232                 if (_ptr_datatype) {
14233                         NDR_PULL_ALLOC(ndr, r->datatype);
14234                 } else {
14235                         r->datatype = NULL;
14236                 }
14237         }
14238         if (ndr_flags & NDR_BUFFERS) {
14239                 if (r->document_name) {
14240                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14241                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14242                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14243                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14244                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14245                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
14246                         }
14247                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14248                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14249                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14250                 }
14251                 if (r->output_file) {
14252                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14253                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14254                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14255                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14256                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14257                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->output_file), ndr_get_array_length(ndr, &r->output_file));
14258                         }
14259                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14260                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14261                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14262                 }
14263                 if (r->datatype) {
14264                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14265                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14266                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14267                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14268                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14269                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->datatype), ndr_get_array_length(ndr, &r->datatype));
14270                         }
14271                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14272                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14273                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14274                 }
14275         }
14276         return NDR_ERR_SUCCESS;
14277 }
14278
14279 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14280 {
14281         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14282         ndr->depth++;
14283         ndr_print_ptr(ndr, "document_name", r->document_name);
14284         ndr->depth++;
14285         if (r->document_name) {
14286                 ndr_print_string(ndr, "document_name", r->document_name);
14287         }
14288         ndr->depth--;
14289         ndr_print_ptr(ndr, "output_file", r->output_file);
14290         ndr->depth++;
14291         if (r->output_file) {
14292                 ndr_print_string(ndr, "output_file", r->output_file);
14293         }
14294         ndr->depth--;
14295         ndr_print_ptr(ndr, "datatype", r->datatype);
14296         ndr->depth++;
14297         if (r->datatype) {
14298                 ndr_print_string(ndr, "datatype", r->datatype);
14299         }
14300         ndr->depth--;
14301         ndr->depth--;
14302 }
14303
14304 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14305 {
14306         if (ndr_flags & NDR_SCALARS) {
14307                 int level = ndr_push_get_switch_value(ndr, r);
14308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14309                 switch (level) {
14310                         case 1: {
14311                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14312                         break; }
14313
14314                         case 2: {
14315                         break; }
14316
14317                         case 3: {
14318                         break; }
14319
14320                         default: {
14321                         break; }
14322
14323                 }
14324         }
14325         if (ndr_flags & NDR_BUFFERS) {
14326                 int level = ndr_push_get_switch_value(ndr, r);
14327                 switch (level) {
14328                         case 1:
14329                                 if (r->info1) {
14330                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14331                                 }
14332                         break;
14333
14334                         case 2:
14335                         break;
14336
14337                         case 3:
14338                         break;
14339
14340                         default:
14341                         break;
14342
14343                 }
14344         }
14345         return NDR_ERR_SUCCESS;
14346 }
14347
14348 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14349 {
14350         int level;
14351         uint32_t _level;
14352         TALLOC_CTX *_mem_save_info1_0;
14353         level = ndr_pull_get_switch_value(ndr, r);
14354         if (ndr_flags & NDR_SCALARS) {
14355                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14356                 if (_level != level) {
14357                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14358                 }
14359                 switch (level) {
14360                         case 1: {
14361                                 uint32_t _ptr_info1;
14362                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14363                                 if (_ptr_info1) {
14364                                         NDR_PULL_ALLOC(ndr, r->info1);
14365                                 } else {
14366                                         r->info1 = NULL;
14367                                 }
14368                         break; }
14369
14370                         case 2: {
14371                         break; }
14372
14373                         case 3: {
14374                         break; }
14375
14376                         default: {
14377                         break; }
14378
14379                 }
14380         }
14381         if (ndr_flags & NDR_BUFFERS) {
14382                 switch (level) {
14383                         case 1:
14384                                 if (r->info1) {
14385                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14386                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14387                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14388                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14389                                 }
14390                         break;
14391
14392                         case 2:
14393                         break;
14394
14395                         case 3:
14396                         break;
14397
14398                         default:
14399                         break;
14400
14401                 }
14402         }
14403         return NDR_ERR_SUCCESS;
14404 }
14405
14406 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14407 {
14408         int level;
14409         level = ndr_print_get_switch_value(ndr, r);
14410         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14411         switch (level) {
14412                 case 1:
14413                         ndr_print_ptr(ndr, "info1", r->info1);
14414                         ndr->depth++;
14415                         if (r->info1) {
14416                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14417                         }
14418                         ndr->depth--;
14419                 break;
14420
14421                 case 2:
14422                 break;
14423
14424                 case 3:
14425                 break;
14426
14427                 default:
14428                 break;
14429
14430         }
14431 }
14432
14433 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14434 {
14435         if (ndr_flags & NDR_SCALARS) {
14436                 NDR_CHECK(ndr_push_align(ndr, 4));
14437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14438                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14439                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14440                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14441                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14442                 {
14443                         uint32_t _flags_save_string = ndr->flags;
14444                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14445                         {
14446                                 struct ndr_push *_ndr_extra_string;
14447                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14448                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14449                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14450                         }
14451                         ndr->flags = _flags_save_string;
14452                 }
14453         }
14454         if (ndr_flags & NDR_BUFFERS) {
14455         }
14456         return NDR_ERR_SUCCESS;
14457 }
14458
14459 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14460 {
14461         if (ndr_flags & NDR_SCALARS) {
14462                 NDR_CHECK(ndr_pull_align(ndr, 4));
14463                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14464                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14466                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14468                 {
14469                         uint32_t _flags_save_string = ndr->flags;
14470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14471                         {
14472                                 struct ndr_pull *_ndr_extra_string;
14473                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14474                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14475                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14476                         }
14477                         ndr->flags = _flags_save_string;
14478                 }
14479         }
14480         if (ndr_flags & NDR_BUFFERS) {
14481         }
14482         return NDR_ERR_SUCCESS;
14483 }
14484
14485 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14486 {
14487         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14488         ndr->depth++;
14489         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
14490         ndr_print_uint32(ndr, "major", r->major);
14491         ndr_print_uint32(ndr, "minor", r->minor);
14492         ndr_print_uint32(ndr, "build", r->build);
14493         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14494         ndr_print_string(ndr, "extra_string", r->extra_string);
14495         ndr->depth--;
14496 }
14497
14498 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14499 {
14500         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14501 }
14502
14503 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14504 {
14505         if (ndr_flags & NDR_SCALARS) {
14506                 NDR_CHECK(ndr_push_align(ndr, 4));
14507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14512                 {
14513                         uint32_t _flags_save_string = ndr->flags;
14514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14515                         {
14516                                 struct ndr_push *_ndr_extra_string;
14517                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14518                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14519                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14520                         }
14521                         ndr->flags = _flags_save_string;
14522                 }
14523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14524                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14525         }
14526         if (ndr_flags & NDR_BUFFERS) {
14527         }
14528         return NDR_ERR_SUCCESS;
14529 }
14530
14531 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14532 {
14533         if (ndr_flags & NDR_SCALARS) {
14534                 NDR_CHECK(ndr_pull_align(ndr, 4));
14535                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14537                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14539                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14540                 {
14541                         uint32_t _flags_save_string = ndr->flags;
14542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14543                         {
14544                                 struct ndr_pull *_ndr_extra_string;
14545                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14546                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14547                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14548                         }
14549                         ndr->flags = _flags_save_string;
14550                 }
14551                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14552                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14553         }
14554         if (ndr_flags & NDR_BUFFERS) {
14555         }
14556         return NDR_ERR_SUCCESS;
14557 }
14558
14559 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14560 {
14561         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14562         ndr->depth++;
14563         ndr_print_uint32(ndr, "_ndr_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags):r->_ndr_size);
14564         ndr_print_uint32(ndr, "major", r->major);
14565         ndr_print_uint32(ndr, "minor", r->minor);
14566         ndr_print_uint32(ndr, "build", r->build);
14567         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14568         ndr_print_string(ndr, "extra_string", r->extra_string);
14569         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14570         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14571         ndr->depth--;
14572 }
14573
14574 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14575 {
14576         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14577 }
14578
14579 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14580 {
14581         if (ndr_flags & NDR_SCALARS) {
14582                 int level = ndr_push_get_switch_value(ndr, r);
14583                 switch (level) {
14584                         case REG_NONE: {
14585                         break; }
14586
14587                         case REG_SZ: {
14588                                 {
14589                                         uint32_t _flags_save_string = ndr->flags;
14590                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14591                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14592                                         ndr->flags = _flags_save_string;
14593                                 }
14594                         break; }
14595
14596                         case REG_BINARY: {
14597                                 {
14598                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14599                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14600                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14601                                         ndr->flags = _flags_save_DATA_BLOB;
14602                                 }
14603                         break; }
14604
14605                         case REG_DWORD: {
14606                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14607                         break; }
14608
14609                         case REG_MULTI_SZ: {
14610                                 {
14611                                         uint32_t _flags_save_string_array = ndr->flags;
14612                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14613                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14614                                         ndr->flags = _flags_save_string_array;
14615                                 }
14616                         break; }
14617
14618                         default: {
14619                                 {
14620                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14621                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14622                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->data));
14623                                         ndr->flags = _flags_save_DATA_BLOB;
14624                                 }
14625                         break; }
14626
14627                 }
14628         }
14629         if (ndr_flags & NDR_BUFFERS) {
14630                 int level = ndr_push_get_switch_value(ndr, r);
14631                 switch (level) {
14632                         case REG_NONE:
14633                         break;
14634
14635                         case REG_SZ:
14636                         break;
14637
14638                         case REG_BINARY:
14639                         break;
14640
14641                         case REG_DWORD:
14642                         break;
14643
14644                         case REG_MULTI_SZ:
14645                         break;
14646
14647                         default:
14648                         break;
14649
14650                 }
14651         }
14652         return NDR_ERR_SUCCESS;
14653 }
14654
14655 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14656 {
14657         int level;
14658         level = ndr_pull_get_switch_value(ndr, r);
14659         if (ndr_flags & NDR_SCALARS) {
14660                 switch (level) {
14661                         case REG_NONE: {
14662                         break; }
14663
14664                         case REG_SZ: {
14665                                 {
14666                                         uint32_t _flags_save_string = ndr->flags;
14667                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14668                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14669                                         ndr->flags = _flags_save_string;
14670                                 }
14671                         break; }
14672
14673                         case REG_BINARY: {
14674                                 {
14675                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14676                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14677                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14678                                         ndr->flags = _flags_save_DATA_BLOB;
14679                                 }
14680                         break; }
14681
14682                         case REG_DWORD: {
14683                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14684                         break; }
14685
14686                         case REG_MULTI_SZ: {
14687                                 {
14688                                         uint32_t _flags_save_string_array = ndr->flags;
14689                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14690                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14691                                         ndr->flags = _flags_save_string_array;
14692                                 }
14693                         break; }
14694
14695                         default: {
14696                                 {
14697                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14698                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14699                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->data));
14700                                         ndr->flags = _flags_save_DATA_BLOB;
14701                                 }
14702                         break; }
14703
14704                 }
14705         }
14706         if (ndr_flags & NDR_BUFFERS) {
14707                 switch (level) {
14708                         case REG_NONE:
14709                         break;
14710
14711                         case REG_SZ:
14712                         break;
14713
14714                         case REG_BINARY:
14715                         break;
14716
14717                         case REG_DWORD:
14718                         break;
14719
14720                         case REG_MULTI_SZ:
14721                         break;
14722
14723                         default:
14724                         break;
14725
14726                 }
14727         }
14728         return NDR_ERR_SUCCESS;
14729 }
14730
14731 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14732 {
14733         int level;
14734         level = ndr_print_get_switch_value(ndr, r);
14735         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14736         switch (level) {
14737                 case REG_NONE:
14738                 break;
14739
14740                 case REG_SZ:
14741                         ndr_print_string(ndr, "string", r->string);
14742                 break;
14743
14744                 case REG_BINARY:
14745                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14746                 break;
14747
14748                 case REG_DWORD:
14749                         ndr_print_uint32(ndr, "value", r->value);
14750                 break;
14751
14752                 case REG_MULTI_SZ:
14753                         ndr_print_string_array(ndr, "string_array", r->string_array);
14754                 break;
14755
14756                 default:
14757                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14758                 break;
14759
14760         }
14761 }
14762
14763 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14764 {
14765         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14766 }
14767
14768 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14769 {
14770         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14771         return NDR_ERR_SUCCESS;
14772 }
14773
14774 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14775 {
14776         uint32_t v;
14777         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14778         *r = v;
14779         return NDR_ERR_SUCCESS;
14780 }
14781
14782 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14783 {
14784         const char *val = NULL;
14785
14786         switch (r) {
14787                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14788                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14789                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14790         }
14791         ndr_print_enum(ndr, name, "ENUM", val, r);
14792 }
14793
14794 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14795 {
14796         if (ndr_flags & NDR_SCALARS) {
14797                 NDR_CHECK(ndr_push_align(ndr, 4));
14798                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14799                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14800         }
14801         if (ndr_flags & NDR_BUFFERS) {
14802         }
14803         return NDR_ERR_SUCCESS;
14804 }
14805
14806 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14807 {
14808         if (ndr_flags & NDR_SCALARS) {
14809                 NDR_CHECK(ndr_pull_align(ndr, 4));
14810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14811                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14812         }
14813         if (ndr_flags & NDR_BUFFERS) {
14814         }
14815         return NDR_ERR_SUCCESS;
14816 }
14817
14818 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14819 {
14820         ndr_print_struct(ndr, name, "spoolss_FormSize");
14821         ndr->depth++;
14822         ndr_print_uint32(ndr, "width", r->width);
14823         ndr_print_uint32(ndr, "height", r->height);
14824         ndr->depth--;
14825 }
14826
14827 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14828 {
14829         if (ndr_flags & NDR_SCALARS) {
14830                 NDR_CHECK(ndr_push_align(ndr, 4));
14831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14833                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14834                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14835         }
14836         if (ndr_flags & NDR_BUFFERS) {
14837         }
14838         return NDR_ERR_SUCCESS;
14839 }
14840
14841 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14842 {
14843         if (ndr_flags & NDR_SCALARS) {
14844                 NDR_CHECK(ndr_pull_align(ndr, 4));
14845                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14846                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14847                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14849         }
14850         if (ndr_flags & NDR_BUFFERS) {
14851         }
14852         return NDR_ERR_SUCCESS;
14853 }
14854
14855 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14856 {
14857         ndr_print_struct(ndr, name, "spoolss_FormArea");
14858         ndr->depth++;
14859         ndr_print_uint32(ndr, "left", r->left);
14860         ndr_print_uint32(ndr, "top", r->top);
14861         ndr_print_uint32(ndr, "right", r->right);
14862         ndr_print_uint32(ndr, "bottom", r->bottom);
14863         ndr->depth--;
14864 }
14865
14866 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14867 {
14868         if (ndr_flags & NDR_SCALARS) {
14869                 NDR_CHECK(ndr_push_align(ndr, 4));
14870                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14871                 {
14872                         uint32_t _flags_save_string = ndr->flags;
14873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14874                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14875                         ndr->flags = _flags_save_string;
14876                 }
14877                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14878                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14879         }
14880         if (ndr_flags & NDR_BUFFERS) {
14881                 {
14882                         uint32_t _flags_save_string = ndr->flags;
14883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14884                         if (r->form_name) {
14885                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14886                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14887                         }
14888                         ndr->flags = _flags_save_string;
14889                 }
14890         }
14891         return NDR_ERR_SUCCESS;
14892 }
14893
14894 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14895 {
14896         uint32_t _ptr_form_name;
14897         TALLOC_CTX *_mem_save_form_name_0;
14898         if (ndr_flags & NDR_SCALARS) {
14899                 NDR_CHECK(ndr_pull_align(ndr, 4));
14900                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14901                 {
14902                         uint32_t _flags_save_string = ndr->flags;
14903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14904                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14905                         if (_ptr_form_name) {
14906                                 NDR_PULL_ALLOC(ndr, r->form_name);
14907                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14908                         } else {
14909                                 r->form_name = NULL;
14910                         }
14911                         ndr->flags = _flags_save_string;
14912                 }
14913                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14914                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14915         }
14916         if (ndr_flags & NDR_BUFFERS) {
14917                 {
14918                         uint32_t _flags_save_string = ndr->flags;
14919                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14920                         if (r->form_name) {
14921                                 uint32_t _relative_save_offset;
14922                                 _relative_save_offset = ndr->offset;
14923                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14924                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14925                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14926                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14927                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14928                                 ndr->offset = _relative_save_offset;
14929                         }
14930                         ndr->flags = _flags_save_string;
14931                 }
14932         }
14933         return NDR_ERR_SUCCESS;
14934 }
14935
14936 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14937 {
14938         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14939         ndr->depth++;
14940         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14941         ndr_print_ptr(ndr, "form_name", r->form_name);
14942         ndr->depth++;
14943         if (r->form_name) {
14944                 ndr_print_string(ndr, "form_name", r->form_name);
14945         }
14946         ndr->depth--;
14947         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14948         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14949         ndr->depth--;
14950 }
14951
14952 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14953 {
14954         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14955 }
14956
14957 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14958 {
14959         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14960         return NDR_ERR_SUCCESS;
14961 }
14962
14963 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14964 {
14965         uint32_t v;
14966         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14967         *r = v;
14968         return NDR_ERR_SUCCESS;
14969 }
14970
14971 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14972 {
14973         ndr_print_uint32(ndr, name, r);
14974         ndr->depth++;
14975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14978         ndr->depth--;
14979 }
14980
14981 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14982 {
14983         if (ndr_flags & NDR_SCALARS) {
14984                 NDR_CHECK(ndr_push_align(ndr, 4));
14985                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14986                 {
14987                         uint32_t _flags_save_string = ndr->flags;
14988                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14989                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14990                         ndr->flags = _flags_save_string;
14991                 }
14992                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14993                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14994                 {
14995                         uint32_t _flags_save_string = ndr->flags;
14996                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14997                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14998                         ndr->flags = _flags_save_string;
14999                 }
15000                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15001                 {
15002                         uint32_t _flags_save_string = ndr->flags;
15003                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15004                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
15005                         ndr->flags = _flags_save_string;
15006                 }
15007                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15008                 {
15009                         uint32_t _flags_save_string = ndr->flags;
15010                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15011                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->display_name));
15012                         ndr->flags = _flags_save_string;
15013                 }
15014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15015         }
15016         if (ndr_flags & NDR_BUFFERS) {
15017                 {
15018                         uint32_t _flags_save_string = ndr->flags;
15019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15020                         if (r->form_name) {
15021                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15022                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15023                         }
15024                         ndr->flags = _flags_save_string;
15025                 }
15026                 {
15027                         uint32_t _flags_save_string = ndr->flags;
15028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15029                         if (r->keyword) {
15030                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15031                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15032                         }
15033                         ndr->flags = _flags_save_string;
15034                 }
15035                 {
15036                         uint32_t _flags_save_string = ndr->flags;
15037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15038                         if (r->mui_dll) {
15039                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15040                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15041                         }
15042                         ndr->flags = _flags_save_string;
15043                 }
15044                 {
15045                         uint32_t _flags_save_string = ndr->flags;
15046                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15047                         if (r->display_name) {
15048                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15049                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15050                         }
15051                         ndr->flags = _flags_save_string;
15052                 }
15053         }
15054         return NDR_ERR_SUCCESS;
15055 }
15056
15057 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15058 {
15059         uint32_t _ptr_form_name;
15060         TALLOC_CTX *_mem_save_form_name_0;
15061         uint32_t _ptr_keyword;
15062         TALLOC_CTX *_mem_save_keyword_0;
15063         uint32_t _ptr_mui_dll;
15064         TALLOC_CTX *_mem_save_mui_dll_0;
15065         uint32_t _ptr_display_name;
15066         TALLOC_CTX *_mem_save_display_name_0;
15067         if (ndr_flags & NDR_SCALARS) {
15068                 NDR_CHECK(ndr_pull_align(ndr, 4));
15069                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15070                 {
15071                         uint32_t _flags_save_string = ndr->flags;
15072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15073                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15074                         if (_ptr_form_name) {
15075                                 NDR_PULL_ALLOC(ndr, r->form_name);
15076                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15077                         } else {
15078                                 r->form_name = NULL;
15079                         }
15080                         ndr->flags = _flags_save_string;
15081                 }
15082                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15083                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15084                 {
15085                         uint32_t _flags_save_string = ndr->flags;
15086                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15087                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15088                         if (_ptr_keyword) {
15089                                 NDR_PULL_ALLOC(ndr, r->keyword);
15090                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15091                         } else {
15092                                 r->keyword = NULL;
15093                         }
15094                         ndr->flags = _flags_save_string;
15095                 }
15096                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15097                 {
15098                         uint32_t _flags_save_string = ndr->flags;
15099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15100                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15101                         if (_ptr_mui_dll) {
15102                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15103                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15104                         } else {
15105                                 r->mui_dll = NULL;
15106                         }
15107                         ndr->flags = _flags_save_string;
15108                 }
15109                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15110                 {
15111                         uint32_t _flags_save_string = ndr->flags;
15112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15113                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15114                         if (_ptr_display_name) {
15115                                 NDR_PULL_ALLOC(ndr, r->display_name);
15116                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15117                         } else {
15118                                 r->display_name = NULL;
15119                         }
15120                         ndr->flags = _flags_save_string;
15121                 }
15122                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15123         }
15124         if (ndr_flags & NDR_BUFFERS) {
15125                 {
15126                         uint32_t _flags_save_string = ndr->flags;
15127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15128                         if (r->form_name) {
15129                                 uint32_t _relative_save_offset;
15130                                 _relative_save_offset = ndr->offset;
15131                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15132                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15133                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15134                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15135                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15136                                 ndr->offset = _relative_save_offset;
15137                         }
15138                         ndr->flags = _flags_save_string;
15139                 }
15140                 {
15141                         uint32_t _flags_save_string = ndr->flags;
15142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15143                         if (r->keyword) {
15144                                 uint32_t _relative_save_offset;
15145                                 _relative_save_offset = ndr->offset;
15146                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15147                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15148                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15149                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15150                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15151                                 ndr->offset = _relative_save_offset;
15152                         }
15153                         ndr->flags = _flags_save_string;
15154                 }
15155                 {
15156                         uint32_t _flags_save_string = ndr->flags;
15157                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15158                         if (r->mui_dll) {
15159                                 uint32_t _relative_save_offset;
15160                                 _relative_save_offset = ndr->offset;
15161                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15162                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15163                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15164                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15165                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15166                                 ndr->offset = _relative_save_offset;
15167                         }
15168                         ndr->flags = _flags_save_string;
15169                 }
15170                 {
15171                         uint32_t _flags_save_string = ndr->flags;
15172                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15173                         if (r->display_name) {
15174                                 uint32_t _relative_save_offset;
15175                                 _relative_save_offset = ndr->offset;
15176                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15177                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15178                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15179                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15180                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15181                                 ndr->offset = _relative_save_offset;
15182                         }
15183                         ndr->flags = _flags_save_string;
15184                 }
15185         }
15186         return NDR_ERR_SUCCESS;
15187 }
15188
15189 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15190 {
15191         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15192         ndr->depth++;
15193         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15194         ndr_print_ptr(ndr, "form_name", r->form_name);
15195         ndr->depth++;
15196         if (r->form_name) {
15197                 ndr_print_string(ndr, "form_name", r->form_name);
15198         }
15199         ndr->depth--;
15200         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15201         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15202         ndr_print_ptr(ndr, "keyword", r->keyword);
15203         ndr->depth++;
15204         if (r->keyword) {
15205                 ndr_print_string(ndr, "keyword", r->keyword);
15206         }
15207         ndr->depth--;
15208         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15209         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15210         ndr->depth++;
15211         if (r->mui_dll) {
15212                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15213         }
15214         ndr->depth--;
15215         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15216         ndr_print_ptr(ndr, "display_name", r->display_name);
15217         ndr->depth++;
15218         if (r->display_name) {
15219                 ndr_print_string(ndr, "display_name", r->display_name);
15220         }
15221         ndr->depth--;
15222         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15223         ndr->depth--;
15224 }
15225
15226 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15227 {
15228         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15229 }
15230
15231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15232 {
15233         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15234         if (ndr_flags & NDR_SCALARS) {
15235                 int level = ndr_push_get_switch_value(ndr, r);
15236                 switch (level) {
15237                         case 1: {
15238                                 NDR_CHECK(ndr_push_align(ndr, 4));
15239                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15240                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15241                         break; }
15242
15243                         case 2: {
15244                                 NDR_CHECK(ndr_push_align(ndr, 4));
15245                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15246                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15247                         break; }
15248
15249                         default: {
15250                         break; }
15251
15252                 }
15253         }
15254         if (ndr_flags & NDR_BUFFERS) {
15255                 int level = ndr_push_get_switch_value(ndr, r);
15256                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15257                 switch (level) {
15258                         case 1:
15259                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15260                         break;
15261
15262                         case 2:
15263                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15264                         break;
15265
15266                         default:
15267                         break;
15268
15269                 }
15270         }
15271         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15272         return NDR_ERR_SUCCESS;
15273 }
15274
15275 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15276 {
15277         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15278         int level;
15279         level = ndr_pull_get_switch_value(ndr, r);
15280         if (ndr_flags & NDR_SCALARS) {
15281                 switch (level) {
15282                         case 1: {
15283                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15284                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15285                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15286                         break; }
15287
15288                         case 2: {
15289                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15290                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15291                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15292                         break; }
15293
15294                         default: {
15295                         break; }
15296
15297                 }
15298         }
15299         if (ndr_flags & NDR_BUFFERS) {
15300                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15301                 switch (level) {
15302                         case 1:
15303                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15304                         break;
15305
15306                         case 2:
15307                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15308                         break;
15309
15310                         default:
15311                         break;
15312
15313                 }
15314         }
15315         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15316         return NDR_ERR_SUCCESS;
15317 }
15318
15319 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15320 {
15321         int level;
15322         level = ndr_print_get_switch_value(ndr, r);
15323         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15324         switch (level) {
15325                 case 1:
15326                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15327                 break;
15328
15329                 case 2:
15330                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15331                 break;
15332
15333                 default:
15334                 break;
15335
15336         }
15337 }
15338
15339 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15340 {
15341         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15342 }
15343
15344 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15345 {
15346         if (ndr_flags & NDR_SCALARS) {
15347                 NDR_CHECK(ndr_push_align(ndr, 4));
15348                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15349                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15350                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15351                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15352         }
15353         if (ndr_flags & NDR_BUFFERS) {
15354                 if (r->form_name) {
15355                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15356                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15357                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15358                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15359                 }
15360         }
15361         return NDR_ERR_SUCCESS;
15362 }
15363
15364 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15365 {
15366         uint32_t _ptr_form_name;
15367         TALLOC_CTX *_mem_save_form_name_0;
15368         if (ndr_flags & NDR_SCALARS) {
15369                 NDR_CHECK(ndr_pull_align(ndr, 4));
15370                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15371                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15372                 if (_ptr_form_name) {
15373                         NDR_PULL_ALLOC(ndr, r->form_name);
15374                 } else {
15375                         r->form_name = NULL;
15376                 }
15377                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15378                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15379         }
15380         if (ndr_flags & NDR_BUFFERS) {
15381                 if (r->form_name) {
15382                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15383                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15384                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15385                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15386                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15387                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
15388                         }
15389                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15390                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15391                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15392                 }
15393         }
15394         return NDR_ERR_SUCCESS;
15395 }
15396
15397 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15398 {
15399         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15400         ndr->depth++;
15401         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15402         ndr_print_ptr(ndr, "form_name", r->form_name);
15403         ndr->depth++;
15404         if (r->form_name) {
15405                 ndr_print_string(ndr, "form_name", r->form_name);
15406         }
15407         ndr->depth--;
15408         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15409         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15410         ndr->depth--;
15411 }
15412
15413 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15414 {
15415         if (ndr_flags & NDR_SCALARS) {
15416                 NDR_CHECK(ndr_push_align(ndr, 4));
15417                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15418                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15419                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15420                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15422                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15423                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15424                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15425                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15426                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15427         }
15428         if (ndr_flags & NDR_BUFFERS) {
15429                 if (r->form_name) {
15430                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15433                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15434                 }
15435                 if (r->keyword) {
15436                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15439                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15440                 }
15441                 if (r->mui_dll) {
15442                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15445                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15446                 }
15447                 if (r->display_name) {
15448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15452                 }
15453         }
15454         return NDR_ERR_SUCCESS;
15455 }
15456
15457 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15458 {
15459         uint32_t _ptr_form_name;
15460         TALLOC_CTX *_mem_save_form_name_0;
15461         uint32_t _ptr_keyword;
15462         TALLOC_CTX *_mem_save_keyword_0;
15463         uint32_t _ptr_mui_dll;
15464         TALLOC_CTX *_mem_save_mui_dll_0;
15465         uint32_t _ptr_display_name;
15466         TALLOC_CTX *_mem_save_display_name_0;
15467         if (ndr_flags & NDR_SCALARS) {
15468                 NDR_CHECK(ndr_pull_align(ndr, 4));
15469                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15471                 if (_ptr_form_name) {
15472                         NDR_PULL_ALLOC(ndr, r->form_name);
15473                 } else {
15474                         r->form_name = NULL;
15475                 }
15476                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15477                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15478                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15479                 if (_ptr_keyword) {
15480                         NDR_PULL_ALLOC(ndr, r->keyword);
15481                 } else {
15482                         r->keyword = NULL;
15483                 }
15484                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15485                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15486                 if (_ptr_mui_dll) {
15487                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15488                 } else {
15489                         r->mui_dll = NULL;
15490                 }
15491                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15492                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15493                 if (_ptr_display_name) {
15494                         NDR_PULL_ALLOC(ndr, r->display_name);
15495                 } else {
15496                         r->display_name = NULL;
15497                 }
15498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15499         }
15500         if (ndr_flags & NDR_BUFFERS) {
15501                 if (r->form_name) {
15502                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15503                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15504                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15505                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15506                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15507                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->form_name), ndr_get_array_length(ndr, &r->form_name));
15508                         }
15509                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15510                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15511                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15512                 }
15513                 if (r->keyword) {
15514                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15515                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15516                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15517                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15518                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15519                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->keyword), ndr_get_array_length(ndr, &r->keyword));
15520                         }
15521                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15522                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15523                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15524                 }
15525                 if (r->mui_dll) {
15526                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15527                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15528                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15529                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15530                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15531                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->mui_dll), ndr_get_array_length(ndr, &r->mui_dll));
15532                         }
15533                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15534                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15535                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15536                 }
15537                 if (r->display_name) {
15538                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15539                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15540                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15541                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15542                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15543                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->display_name), ndr_get_array_length(ndr, &r->display_name));
15544                         }
15545                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15546                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15548                 }
15549         }
15550         return NDR_ERR_SUCCESS;
15551 }
15552
15553 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15554 {
15555         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15556         ndr->depth++;
15557         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15558         ndr_print_ptr(ndr, "form_name", r->form_name);
15559         ndr->depth++;
15560         if (r->form_name) {
15561                 ndr_print_string(ndr, "form_name", r->form_name);
15562         }
15563         ndr->depth--;
15564         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15565         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15566         ndr_print_ptr(ndr, "keyword", r->keyword);
15567         ndr->depth++;
15568         if (r->keyword) {
15569                 ndr_print_string(ndr, "keyword", r->keyword);
15570         }
15571         ndr->depth--;
15572         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15573         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15574         ndr->depth++;
15575         if (r->mui_dll) {
15576                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15577         }
15578         ndr->depth--;
15579         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15580         ndr_print_ptr(ndr, "display_name", r->display_name);
15581         ndr->depth++;
15582         if (r->display_name) {
15583                 ndr_print_string(ndr, "display_name", r->display_name);
15584         }
15585         ndr->depth--;
15586         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15587         ndr->depth--;
15588 }
15589
15590 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15591 {
15592         if (ndr_flags & NDR_SCALARS) {
15593                 int level = ndr_push_get_switch_value(ndr, r);
15594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15595                 switch (level) {
15596                         case 1: {
15597                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15598                         break; }
15599
15600                         case 2: {
15601                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15602                         break; }
15603
15604                         default:
15605                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15606                 }
15607         }
15608         if (ndr_flags & NDR_BUFFERS) {
15609                 int level = ndr_push_get_switch_value(ndr, r);
15610                 switch (level) {
15611                         case 1:
15612                                 if (r->info1) {
15613                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15614                                 }
15615                         break;
15616
15617                         case 2:
15618                                 if (r->info2) {
15619                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15620                                 }
15621                         break;
15622
15623                         default:
15624                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15625                 }
15626         }
15627         return NDR_ERR_SUCCESS;
15628 }
15629
15630 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15631 {
15632         int level;
15633         uint32_t _level;
15634         TALLOC_CTX *_mem_save_info1_0;
15635         TALLOC_CTX *_mem_save_info2_0;
15636         level = ndr_pull_get_switch_value(ndr, r);
15637         if (ndr_flags & NDR_SCALARS) {
15638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15639                 if (_level != level) {
15640                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15641                 }
15642                 switch (level) {
15643                         case 1: {
15644                                 uint32_t _ptr_info1;
15645                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15646                                 if (_ptr_info1) {
15647                                         NDR_PULL_ALLOC(ndr, r->info1);
15648                                 } else {
15649                                         r->info1 = NULL;
15650                                 }
15651                         break; }
15652
15653                         case 2: {
15654                                 uint32_t _ptr_info2;
15655                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15656                                 if (_ptr_info2) {
15657                                         NDR_PULL_ALLOC(ndr, r->info2);
15658                                 } else {
15659                                         r->info2 = NULL;
15660                                 }
15661                         break; }
15662
15663                         default:
15664                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15665                 }
15666         }
15667         if (ndr_flags & NDR_BUFFERS) {
15668                 switch (level) {
15669                         case 1:
15670                                 if (r->info1) {
15671                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15672                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15673                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15674                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15675                                 }
15676                         break;
15677
15678                         case 2:
15679                                 if (r->info2) {
15680                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15681                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15682                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15683                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15684                                 }
15685                         break;
15686
15687                         default:
15688                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15689                 }
15690         }
15691         return NDR_ERR_SUCCESS;
15692 }
15693
15694 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15695 {
15696         int level;
15697         level = ndr_print_get_switch_value(ndr, r);
15698         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15699         switch (level) {
15700                 case 1:
15701                         ndr_print_ptr(ndr, "info1", r->info1);
15702                         ndr->depth++;
15703                         if (r->info1) {
15704                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15705                         }
15706                         ndr->depth--;
15707                 break;
15708
15709                 case 2:
15710                         ndr_print_ptr(ndr, "info2", r->info2);
15711                         ndr->depth++;
15712                         if (r->info2) {
15713                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15714                         }
15715                         ndr->depth--;
15716                 break;
15717
15718                 default:
15719                         ndr_print_bad_level(ndr, name, level);
15720         }
15721 }
15722
15723 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15724 {
15725         if (ndr_flags & NDR_SCALARS) {
15726                 NDR_CHECK(ndr_push_align(ndr, 4));
15727                 {
15728                         uint32_t _flags_save_string = ndr->flags;
15729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15730                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15731                         ndr->flags = _flags_save_string;
15732                 }
15733         }
15734         if (ndr_flags & NDR_BUFFERS) {
15735                 {
15736                         uint32_t _flags_save_string = ndr->flags;
15737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15738                         if (r->port_name) {
15739                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15740                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15741                         }
15742                         ndr->flags = _flags_save_string;
15743                 }
15744         }
15745         return NDR_ERR_SUCCESS;
15746 }
15747
15748 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15749 {
15750         uint32_t _ptr_port_name;
15751         TALLOC_CTX *_mem_save_port_name_0;
15752         if (ndr_flags & NDR_SCALARS) {
15753                 NDR_CHECK(ndr_pull_align(ndr, 4));
15754                 {
15755                         uint32_t _flags_save_string = ndr->flags;
15756                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15757                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15758                         if (_ptr_port_name) {
15759                                 NDR_PULL_ALLOC(ndr, r->port_name);
15760                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15761                         } else {
15762                                 r->port_name = NULL;
15763                         }
15764                         ndr->flags = _flags_save_string;
15765                 }
15766         }
15767         if (ndr_flags & NDR_BUFFERS) {
15768                 {
15769                         uint32_t _flags_save_string = ndr->flags;
15770                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15771                         if (r->port_name) {
15772                                 uint32_t _relative_save_offset;
15773                                 _relative_save_offset = ndr->offset;
15774                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15775                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15776                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15777                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15778                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15779                                 ndr->offset = _relative_save_offset;
15780                         }
15781                         ndr->flags = _flags_save_string;
15782                 }
15783         }
15784         return NDR_ERR_SUCCESS;
15785 }
15786
15787 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15788 {
15789         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15790         ndr->depth++;
15791         ndr_print_ptr(ndr, "port_name", r->port_name);
15792         ndr->depth++;
15793         if (r->port_name) {
15794                 ndr_print_string(ndr, "port_name", r->port_name);
15795         }
15796         ndr->depth--;
15797         ndr->depth--;
15798 }
15799
15800 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15801 {
15802         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15803 }
15804
15805 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15806 {
15807         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15808         return NDR_ERR_SUCCESS;
15809 }
15810
15811 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15812 {
15813         uint32_t v;
15814         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15815         *r = v;
15816         return NDR_ERR_SUCCESS;
15817 }
15818
15819 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15820 {
15821         ndr_print_uint32(ndr, name, r);
15822         ndr->depth++;
15823         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15824         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15825         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15826         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15827         ndr->depth--;
15828 }
15829
15830 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15831 {
15832         if (ndr_flags & NDR_SCALARS) {
15833                 NDR_CHECK(ndr_push_align(ndr, 4));
15834                 {
15835                         uint32_t _flags_save_string = ndr->flags;
15836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15837                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15838                         ndr->flags = _flags_save_string;
15839                 }
15840                 {
15841                         uint32_t _flags_save_string = ndr->flags;
15842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15843                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15844                         ndr->flags = _flags_save_string;
15845                 }
15846                 {
15847                         uint32_t _flags_save_string = ndr->flags;
15848                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15849                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15850                         ndr->flags = _flags_save_string;
15851                 }
15852                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15853                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15854         }
15855         if (ndr_flags & NDR_BUFFERS) {
15856                 {
15857                         uint32_t _flags_save_string = ndr->flags;
15858                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15859                         if (r->port_name) {
15860                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15861                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15862                         }
15863                         ndr->flags = _flags_save_string;
15864                 }
15865                 {
15866                         uint32_t _flags_save_string = ndr->flags;
15867                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15868                         if (r->monitor_name) {
15869                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15870                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15871                         }
15872                         ndr->flags = _flags_save_string;
15873                 }
15874                 {
15875                         uint32_t _flags_save_string = ndr->flags;
15876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15877                         if (r->description) {
15878                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15879                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15880                         }
15881                         ndr->flags = _flags_save_string;
15882                 }
15883         }
15884         return NDR_ERR_SUCCESS;
15885 }
15886
15887 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15888 {
15889         uint32_t _ptr_port_name;
15890         TALLOC_CTX *_mem_save_port_name_0;
15891         uint32_t _ptr_monitor_name;
15892         TALLOC_CTX *_mem_save_monitor_name_0;
15893         uint32_t _ptr_description;
15894         TALLOC_CTX *_mem_save_description_0;
15895         if (ndr_flags & NDR_SCALARS) {
15896                 NDR_CHECK(ndr_pull_align(ndr, 4));
15897                 {
15898                         uint32_t _flags_save_string = ndr->flags;
15899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15900                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15901                         if (_ptr_port_name) {
15902                                 NDR_PULL_ALLOC(ndr, r->port_name);
15903                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15904                         } else {
15905                                 r->port_name = NULL;
15906                         }
15907                         ndr->flags = _flags_save_string;
15908                 }
15909                 {
15910                         uint32_t _flags_save_string = ndr->flags;
15911                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15912                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15913                         if (_ptr_monitor_name) {
15914                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15915                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15916                         } else {
15917                                 r->monitor_name = NULL;
15918                         }
15919                         ndr->flags = _flags_save_string;
15920                 }
15921                 {
15922                         uint32_t _flags_save_string = ndr->flags;
15923                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15924                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15925                         if (_ptr_description) {
15926                                 NDR_PULL_ALLOC(ndr, r->description);
15927                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15928                         } else {
15929                                 r->description = NULL;
15930                         }
15931                         ndr->flags = _flags_save_string;
15932                 }
15933                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15934                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15935         }
15936         if (ndr_flags & NDR_BUFFERS) {
15937                 {
15938                         uint32_t _flags_save_string = ndr->flags;
15939                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15940                         if (r->port_name) {
15941                                 uint32_t _relative_save_offset;
15942                                 _relative_save_offset = ndr->offset;
15943                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15944                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15945                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15946                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15947                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15948                                 ndr->offset = _relative_save_offset;
15949                         }
15950                         ndr->flags = _flags_save_string;
15951                 }
15952                 {
15953                         uint32_t _flags_save_string = ndr->flags;
15954                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15955                         if (r->monitor_name) {
15956                                 uint32_t _relative_save_offset;
15957                                 _relative_save_offset = ndr->offset;
15958                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15959                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15960                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15961                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15962                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15963                                 ndr->offset = _relative_save_offset;
15964                         }
15965                         ndr->flags = _flags_save_string;
15966                 }
15967                 {
15968                         uint32_t _flags_save_string = ndr->flags;
15969                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15970                         if (r->description) {
15971                                 uint32_t _relative_save_offset;
15972                                 _relative_save_offset = ndr->offset;
15973                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15974                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15975                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15976                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15977                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15978                                 ndr->offset = _relative_save_offset;
15979                         }
15980                         ndr->flags = _flags_save_string;
15981                 }
15982         }
15983         return NDR_ERR_SUCCESS;
15984 }
15985
15986 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15987 {
15988         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15989         ndr->depth++;
15990         ndr_print_ptr(ndr, "port_name", r->port_name);
15991         ndr->depth++;
15992         if (r->port_name) {
15993                 ndr_print_string(ndr, "port_name", r->port_name);
15994         }
15995         ndr->depth--;
15996         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15997         ndr->depth++;
15998         if (r->monitor_name) {
15999                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16000         }
16001         ndr->depth--;
16002         ndr_print_ptr(ndr, "description", r->description);
16003         ndr->depth++;
16004         if (r->description) {
16005                 ndr_print_string(ndr, "description", r->description);
16006         }
16007         ndr->depth--;
16008         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
16009         ndr_print_uint32(ndr, "reserved", r->reserved);
16010         ndr->depth--;
16011 }
16012
16013 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16014 {
16015         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
16016 }
16017
16018 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
16019 {
16020         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16021         return NDR_ERR_SUCCESS;
16022 }
16023
16024 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16025 {
16026         uint32_t v;
16027         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16028         *r = v;
16029         return NDR_ERR_SUCCESS;
16030 }
16031
16032 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16033 {
16034         const char *val = NULL;
16035
16036         switch (r) {
16037                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16038                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16039                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16040                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16041                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16042                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16043                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16044                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16045                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16046                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16047                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16048                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16049                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16050         }
16051         ndr_print_enum(ndr, name, "ENUM", val, r);
16052 }
16053
16054 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16055 {
16056         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16057         return NDR_ERR_SUCCESS;
16058 }
16059
16060 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16061 {
16062         uint32_t v;
16063         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16064         *r = v;
16065         return NDR_ERR_SUCCESS;
16066 }
16067
16068 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16069 {
16070         const char *val = NULL;
16071
16072         switch (r) {
16073                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16074                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16075                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16076         }
16077         ndr_print_enum(ndr, name, "ENUM", val, r);
16078 }
16079
16080 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16081 {
16082         if (ndr_flags & NDR_SCALARS) {
16083                 NDR_CHECK(ndr_push_align(ndr, 4));
16084                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16085                 {
16086                         uint32_t _flags_save_string = ndr->flags;
16087                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16088                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16089                         ndr->flags = _flags_save_string;
16090                 }
16091                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16092         }
16093         if (ndr_flags & NDR_BUFFERS) {
16094                 {
16095                         uint32_t _flags_save_string = ndr->flags;
16096                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16097                         if (r->status_string) {
16098                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16099                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16100                         }
16101                         ndr->flags = _flags_save_string;
16102                 }
16103         }
16104         return NDR_ERR_SUCCESS;
16105 }
16106
16107 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16108 {
16109         uint32_t _ptr_status_string;
16110         TALLOC_CTX *_mem_save_status_string_0;
16111         if (ndr_flags & NDR_SCALARS) {
16112                 NDR_CHECK(ndr_pull_align(ndr, 4));
16113                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16114                 {
16115                         uint32_t _flags_save_string = ndr->flags;
16116                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16117                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16118                         if (_ptr_status_string) {
16119                                 NDR_PULL_ALLOC(ndr, r->status_string);
16120                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16121                         } else {
16122                                 r->status_string = NULL;
16123                         }
16124                         ndr->flags = _flags_save_string;
16125                 }
16126                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16127         }
16128         if (ndr_flags & NDR_BUFFERS) {
16129                 {
16130                         uint32_t _flags_save_string = ndr->flags;
16131                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16132                         if (r->status_string) {
16133                                 uint32_t _relative_save_offset;
16134                                 _relative_save_offset = ndr->offset;
16135                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16136                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16137                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16138                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16139                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16140                                 ndr->offset = _relative_save_offset;
16141                         }
16142                         ndr->flags = _flags_save_string;
16143                 }
16144         }
16145         return NDR_ERR_SUCCESS;
16146 }
16147
16148 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16149 {
16150         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16151         ndr->depth++;
16152         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16153         ndr_print_ptr(ndr, "status_string", r->status_string);
16154         ndr->depth++;
16155         if (r->status_string) {
16156                 ndr_print_string(ndr, "status_string", r->status_string);
16157         }
16158         ndr->depth--;
16159         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16160         ndr->depth--;
16161 }
16162
16163 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16164 {
16165         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16166 }
16167
16168 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16169 {
16170         if (ndr_flags & NDR_SCALARS) {
16171                 NDR_CHECK(ndr_push_align(ndr, 4));
16172                 {
16173                         uint32_t _flags_save_string = ndr->flags;
16174                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16175                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16176                         ndr->flags = _flags_save_string;
16177                 }
16178                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16179         }
16180         if (ndr_flags & NDR_BUFFERS) {
16181                 {
16182                         uint32_t _flags_save_string = ndr->flags;
16183                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16184                         if (r->port_name) {
16185                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16186                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16187                         }
16188                         ndr->flags = _flags_save_string;
16189                 }
16190         }
16191         return NDR_ERR_SUCCESS;
16192 }
16193
16194 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16195 {
16196         uint32_t _ptr_port_name;
16197         TALLOC_CTX *_mem_save_port_name_0;
16198         if (ndr_flags & NDR_SCALARS) {
16199                 NDR_CHECK(ndr_pull_align(ndr, 4));
16200                 {
16201                         uint32_t _flags_save_string = ndr->flags;
16202                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16203                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16204                         if (_ptr_port_name) {
16205                                 NDR_PULL_ALLOC(ndr, r->port_name);
16206                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16207                         } else {
16208                                 r->port_name = NULL;
16209                         }
16210                         ndr->flags = _flags_save_string;
16211                 }
16212                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16213         }
16214         if (ndr_flags & NDR_BUFFERS) {
16215                 {
16216                         uint32_t _flags_save_string = ndr->flags;
16217                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16218                         if (r->port_name) {
16219                                 uint32_t _relative_save_offset;
16220                                 _relative_save_offset = ndr->offset;
16221                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16222                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16223                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16224                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16225                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16226                                 ndr->offset = _relative_save_offset;
16227                         }
16228                         ndr->flags = _flags_save_string;
16229                 }
16230         }
16231         return NDR_ERR_SUCCESS;
16232 }
16233
16234 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16235 {
16236         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16237         ndr->depth++;
16238         ndr_print_ptr(ndr, "port_name", r->port_name);
16239         ndr->depth++;
16240         if (r->port_name) {
16241                 ndr_print_string(ndr, "port_name", r->port_name);
16242         }
16243         ndr->depth--;
16244         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16245         ndr->depth--;
16246 }
16247
16248 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16249 {
16250         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16251 }
16252
16253 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16254 {
16255         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16256         if (ndr_flags & NDR_SCALARS) {
16257                 int level = ndr_push_get_switch_value(ndr, r);
16258                 switch (level) {
16259                         case 1: {
16260                                 NDR_CHECK(ndr_push_align(ndr, 4));
16261                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16262                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16263                         break; }
16264
16265                         case 2: {
16266                                 NDR_CHECK(ndr_push_align(ndr, 4));
16267                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16268                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16269                         break; }
16270
16271                         case 3: {
16272                                 NDR_CHECK(ndr_push_align(ndr, 4));
16273                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16274                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16275                         break; }
16276
16277                         case 0xff: {
16278                                 NDR_CHECK(ndr_push_align(ndr, 4));
16279                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16280                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16281                         break; }
16282
16283                         default: {
16284                         break; }
16285
16286                 }
16287         }
16288         if (ndr_flags & NDR_BUFFERS) {
16289                 int level = ndr_push_get_switch_value(ndr, r);
16290                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16291                 switch (level) {
16292                         case 1:
16293                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16294                         break;
16295
16296                         case 2:
16297                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16298                         break;
16299
16300                         case 3:
16301                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16302                         break;
16303
16304                         case 0xff:
16305                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16306                         break;
16307
16308                         default:
16309                         break;
16310
16311                 }
16312         }
16313         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16314         return NDR_ERR_SUCCESS;
16315 }
16316
16317 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16318 {
16319         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16320         int level;
16321         level = ndr_pull_get_switch_value(ndr, r);
16322         if (ndr_flags & NDR_SCALARS) {
16323                 switch (level) {
16324                         case 1: {
16325                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16326                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16327                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16328                         break; }
16329
16330                         case 2: {
16331                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16332                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16333                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16334                         break; }
16335
16336                         case 3: {
16337                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16338                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16339                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16340                         break; }
16341
16342                         case 0xff: {
16343                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16344                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16345                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16346                         break; }
16347
16348                         default: {
16349                         break; }
16350
16351                 }
16352         }
16353         if (ndr_flags & NDR_BUFFERS) {
16354                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16355                 switch (level) {
16356                         case 1:
16357                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16358                         break;
16359
16360                         case 2:
16361                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16362                         break;
16363
16364                         case 3:
16365                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16366                         break;
16367
16368                         case 0xff:
16369                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16370                         break;
16371
16372                         default:
16373                         break;
16374
16375                 }
16376         }
16377         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16378         return NDR_ERR_SUCCESS;
16379 }
16380
16381 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16382 {
16383         int level;
16384         level = ndr_print_get_switch_value(ndr, r);
16385         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16386         switch (level) {
16387                 case 1:
16388                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16389                 break;
16390
16391                 case 2:
16392                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16393                 break;
16394
16395                 case 3:
16396                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16397                 break;
16398
16399                 case 0xff:
16400                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16401                 break;
16402
16403                 default:
16404                 break;
16405
16406         }
16407 }
16408
16409 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16410 {
16411         if (ndr_flags & NDR_SCALARS) {
16412                 NDR_CHECK(ndr_push_align(ndr, 4));
16413                 {
16414                         uint32_t _flags_save_string = ndr->flags;
16415                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16416                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16417                         ndr->flags = _flags_save_string;
16418                 }
16419         }
16420         if (ndr_flags & NDR_BUFFERS) {
16421                 {
16422                         uint32_t _flags_save_string = ndr->flags;
16423                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16424                         if (r->monitor_name) {
16425                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16426                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16427                         }
16428                         ndr->flags = _flags_save_string;
16429                 }
16430         }
16431         return NDR_ERR_SUCCESS;
16432 }
16433
16434 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16435 {
16436         uint32_t _ptr_monitor_name;
16437         TALLOC_CTX *_mem_save_monitor_name_0;
16438         if (ndr_flags & NDR_SCALARS) {
16439                 NDR_CHECK(ndr_pull_align(ndr, 4));
16440                 {
16441                         uint32_t _flags_save_string = ndr->flags;
16442                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16443                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16444                         if (_ptr_monitor_name) {
16445                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16446                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16447                         } else {
16448                                 r->monitor_name = NULL;
16449                         }
16450                         ndr->flags = _flags_save_string;
16451                 }
16452         }
16453         if (ndr_flags & NDR_BUFFERS) {
16454                 {
16455                         uint32_t _flags_save_string = ndr->flags;
16456                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16457                         if (r->monitor_name) {
16458                                 uint32_t _relative_save_offset;
16459                                 _relative_save_offset = ndr->offset;
16460                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16461                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16462                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16463                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16464                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16465                                 ndr->offset = _relative_save_offset;
16466                         }
16467                         ndr->flags = _flags_save_string;
16468                 }
16469         }
16470         return NDR_ERR_SUCCESS;
16471 }
16472
16473 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16474 {
16475         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16476         ndr->depth++;
16477         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16478         ndr->depth++;
16479         if (r->monitor_name) {
16480                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16481         }
16482         ndr->depth--;
16483         ndr->depth--;
16484 }
16485
16486 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16487 {
16488         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16489 }
16490
16491 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16492 {
16493         if (ndr_flags & NDR_SCALARS) {
16494                 NDR_CHECK(ndr_push_align(ndr, 4));
16495                 {
16496                         uint32_t _flags_save_string = ndr->flags;
16497                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16498                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16499                         ndr->flags = _flags_save_string;
16500                 }
16501                 {
16502                         uint32_t _flags_save_string = ndr->flags;
16503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16504                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16505                         ndr->flags = _flags_save_string;
16506                 }
16507                 {
16508                         uint32_t _flags_save_string = ndr->flags;
16509                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16510                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16511                         ndr->flags = _flags_save_string;
16512                 }
16513         }
16514         if (ndr_flags & NDR_BUFFERS) {
16515                 {
16516                         uint32_t _flags_save_string = ndr->flags;
16517                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16518                         if (r->monitor_name) {
16519                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16520                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16521                         }
16522                         ndr->flags = _flags_save_string;
16523                 }
16524                 {
16525                         uint32_t _flags_save_string = ndr->flags;
16526                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16527                         if (r->environment) {
16528                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16529                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16530                         }
16531                         ndr->flags = _flags_save_string;
16532                 }
16533                 {
16534                         uint32_t _flags_save_string = ndr->flags;
16535                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16536                         if (r->dll_name) {
16537                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16538                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16539                         }
16540                         ndr->flags = _flags_save_string;
16541                 }
16542         }
16543         return NDR_ERR_SUCCESS;
16544 }
16545
16546 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16547 {
16548         uint32_t _ptr_monitor_name;
16549         TALLOC_CTX *_mem_save_monitor_name_0;
16550         uint32_t _ptr_environment;
16551         TALLOC_CTX *_mem_save_environment_0;
16552         uint32_t _ptr_dll_name;
16553         TALLOC_CTX *_mem_save_dll_name_0;
16554         if (ndr_flags & NDR_SCALARS) {
16555                 NDR_CHECK(ndr_pull_align(ndr, 4));
16556                 {
16557                         uint32_t _flags_save_string = ndr->flags;
16558                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16559                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16560                         if (_ptr_monitor_name) {
16561                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16562                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16563                         } else {
16564                                 r->monitor_name = NULL;
16565                         }
16566                         ndr->flags = _flags_save_string;
16567                 }
16568                 {
16569                         uint32_t _flags_save_string = ndr->flags;
16570                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16571                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16572                         if (_ptr_environment) {
16573                                 NDR_PULL_ALLOC(ndr, r->environment);
16574                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16575                         } else {
16576                                 r->environment = NULL;
16577                         }
16578                         ndr->flags = _flags_save_string;
16579                 }
16580                 {
16581                         uint32_t _flags_save_string = ndr->flags;
16582                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16583                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16584                         if (_ptr_dll_name) {
16585                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16586                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16587                         } else {
16588                                 r->dll_name = NULL;
16589                         }
16590                         ndr->flags = _flags_save_string;
16591                 }
16592         }
16593         if (ndr_flags & NDR_BUFFERS) {
16594                 {
16595                         uint32_t _flags_save_string = ndr->flags;
16596                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16597                         if (r->monitor_name) {
16598                                 uint32_t _relative_save_offset;
16599                                 _relative_save_offset = ndr->offset;
16600                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16601                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16602                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16603                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16604                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16605                                 ndr->offset = _relative_save_offset;
16606                         }
16607                         ndr->flags = _flags_save_string;
16608                 }
16609                 {
16610                         uint32_t _flags_save_string = ndr->flags;
16611                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16612                         if (r->environment) {
16613                                 uint32_t _relative_save_offset;
16614                                 _relative_save_offset = ndr->offset;
16615                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16616                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16617                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16618                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16619                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16620                                 ndr->offset = _relative_save_offset;
16621                         }
16622                         ndr->flags = _flags_save_string;
16623                 }
16624                 {
16625                         uint32_t _flags_save_string = ndr->flags;
16626                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16627                         if (r->dll_name) {
16628                                 uint32_t _relative_save_offset;
16629                                 _relative_save_offset = ndr->offset;
16630                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16631                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16632                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16633                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16634                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16635                                 ndr->offset = _relative_save_offset;
16636                         }
16637                         ndr->flags = _flags_save_string;
16638                 }
16639         }
16640         return NDR_ERR_SUCCESS;
16641 }
16642
16643 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16644 {
16645         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16646         ndr->depth++;
16647         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16648         ndr->depth++;
16649         if (r->monitor_name) {
16650                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16651         }
16652         ndr->depth--;
16653         ndr_print_ptr(ndr, "environment", r->environment);
16654         ndr->depth++;
16655         if (r->environment) {
16656                 ndr_print_string(ndr, "environment", r->environment);
16657         }
16658         ndr->depth--;
16659         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16660         ndr->depth++;
16661         if (r->dll_name) {
16662                 ndr_print_string(ndr, "dll_name", r->dll_name);
16663         }
16664         ndr->depth--;
16665         ndr->depth--;
16666 }
16667
16668 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16669 {
16670         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16671 }
16672
16673 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16674 {
16675         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16676         if (ndr_flags & NDR_SCALARS) {
16677                 int level = ndr_push_get_switch_value(ndr, r);
16678                 switch (level) {
16679                         case 1: {
16680                                 NDR_CHECK(ndr_push_align(ndr, 4));
16681                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16682                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16683                         break; }
16684
16685                         case 2: {
16686                                 NDR_CHECK(ndr_push_align(ndr, 4));
16687                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16688                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16689                         break; }
16690
16691                         default: {
16692                         break; }
16693
16694                 }
16695         }
16696         if (ndr_flags & NDR_BUFFERS) {
16697                 int level = ndr_push_get_switch_value(ndr, r);
16698                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16699                 switch (level) {
16700                         case 1:
16701                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16702                         break;
16703
16704                         case 2:
16705                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16706                         break;
16707
16708                         default:
16709                         break;
16710
16711                 }
16712         }
16713         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16714         return NDR_ERR_SUCCESS;
16715 }
16716
16717 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16718 {
16719         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16720         int level;
16721         level = ndr_pull_get_switch_value(ndr, r);
16722         if (ndr_flags & NDR_SCALARS) {
16723                 switch (level) {
16724                         case 1: {
16725                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16726                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16727                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16728                         break; }
16729
16730                         case 2: {
16731                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16732                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16733                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16734                         break; }
16735
16736                         default: {
16737                         break; }
16738
16739                 }
16740         }
16741         if (ndr_flags & NDR_BUFFERS) {
16742                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16743                 switch (level) {
16744                         case 1:
16745                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16746                         break;
16747
16748                         case 2:
16749                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16750                         break;
16751
16752                         default:
16753                         break;
16754
16755                 }
16756         }
16757         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16758         return NDR_ERR_SUCCESS;
16759 }
16760
16761 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16762 {
16763         int level;
16764         level = ndr_print_get_switch_value(ndr, r);
16765         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16766         switch (level) {
16767                 case 1:
16768                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16769                 break;
16770
16771                 case 2:
16772                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16773                 break;
16774
16775                 default:
16776                 break;
16777
16778         }
16779 }
16780
16781 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16782 {
16783         if (ndr_flags & NDR_SCALARS) {
16784                 NDR_CHECK(ndr_push_align(ndr, 4));
16785                 {
16786                         uint32_t _flags_save_string = ndr->flags;
16787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16788                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16789                         ndr->flags = _flags_save_string;
16790                 }
16791         }
16792         if (ndr_flags & NDR_BUFFERS) {
16793                 {
16794                         uint32_t _flags_save_string = ndr->flags;
16795                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16796                         if (r->name_array) {
16797                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16798                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16799                         }
16800                         ndr->flags = _flags_save_string;
16801                 }
16802         }
16803         return NDR_ERR_SUCCESS;
16804 }
16805
16806 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16807 {
16808         uint32_t _ptr_name_array;
16809         TALLOC_CTX *_mem_save_name_array_0;
16810         if (ndr_flags & NDR_SCALARS) {
16811                 NDR_CHECK(ndr_pull_align(ndr, 4));
16812                 {
16813                         uint32_t _flags_save_string = ndr->flags;
16814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16815                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16816                         if (_ptr_name_array) {
16817                                 NDR_PULL_ALLOC(ndr, r->name_array);
16818                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16819                         } else {
16820                                 r->name_array = NULL;
16821                         }
16822                         ndr->flags = _flags_save_string;
16823                 }
16824         }
16825         if (ndr_flags & NDR_BUFFERS) {
16826                 {
16827                         uint32_t _flags_save_string = ndr->flags;
16828                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16829                         if (r->name_array) {
16830                                 uint32_t _relative_save_offset;
16831                                 _relative_save_offset = ndr->offset;
16832                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16833                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16834                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16835                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16836                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16837                                 ndr->offset = _relative_save_offset;
16838                         }
16839                         ndr->flags = _flags_save_string;
16840                 }
16841         }
16842         return NDR_ERR_SUCCESS;
16843 }
16844
16845 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16846 {
16847         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16848         ndr->depth++;
16849         ndr_print_ptr(ndr, "name_array", r->name_array);
16850         ndr->depth++;
16851         if (r->name_array) {
16852                 ndr_print_string(ndr, "name_array", r->name_array);
16853         }
16854         ndr->depth--;
16855         ndr->depth--;
16856 }
16857
16858 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16859 {
16860         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16861 }
16862
16863 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16864 {
16865         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16866         if (ndr_flags & NDR_SCALARS) {
16867                 int level = ndr_push_get_switch_value(ndr, r);
16868                 switch (level) {
16869                         case 1: {
16870                                 NDR_CHECK(ndr_push_align(ndr, 4));
16871                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16872                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16873                         break; }
16874
16875                         default: {
16876                         break; }
16877
16878                 }
16879         }
16880         if (ndr_flags & NDR_BUFFERS) {
16881                 int level = ndr_push_get_switch_value(ndr, r);
16882                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16883                 switch (level) {
16884                         case 1:
16885                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16886                         break;
16887
16888                         default:
16889                         break;
16890
16891                 }
16892         }
16893         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16894         return NDR_ERR_SUCCESS;
16895 }
16896
16897 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16898 {
16899         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16900         int level;
16901         level = ndr_pull_get_switch_value(ndr, r);
16902         if (ndr_flags & NDR_SCALARS) {
16903                 switch (level) {
16904                         case 1: {
16905                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16906                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16907                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16908                         break; }
16909
16910                         default: {
16911                         break; }
16912
16913                 }
16914         }
16915         if (ndr_flags & NDR_BUFFERS) {
16916                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16917                 switch (level) {
16918                         case 1:
16919                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16920                         break;
16921
16922                         default:
16923                         break;
16924
16925                 }
16926         }
16927         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16928         return NDR_ERR_SUCCESS;
16929 }
16930
16931 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16932 {
16933         int level;
16934         level = ndr_print_get_switch_value(ndr, r);
16935         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16936         switch (level) {
16937                 case 1:
16938                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16939                 break;
16940
16941                 default:
16942                 break;
16943
16944         }
16945 }
16946
16947 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16948 {
16949         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16950         return NDR_ERR_SUCCESS;
16951 }
16952
16953 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16954 {
16955         uint32_t v;
16956         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16957         *r = v;
16958         return NDR_ERR_SUCCESS;
16959 }
16960
16961 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16962 {
16963         ndr_print_uint32(ndr, name, r);
16964         ndr->depth++;
16965         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16966         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16967         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16968         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16985         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16986         ndr->depth--;
16987 }
16988
16989 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
16990 {
16991         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16992         return NDR_ERR_SUCCESS;
16993 }
16994
16995 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
16996 {
16997         uint16_t v;
16998         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16999         *r = v;
17000         return NDR_ERR_SUCCESS;
17001 }
17002
17003 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
17004 {
17005         const char *val = NULL;
17006
17007         switch (r) {
17008                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
17009                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
17010                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
17011                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
17012                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
17013                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
17014                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17015                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
17016                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
17017                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
17018                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
17019                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
17020                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17021                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
17022                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
17023                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
17024                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
17025                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
17026                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
17027                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
17028                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
17029                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
17030                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
17031                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
17032         }
17033         ndr_print_enum(ndr, name, "ENUM", val, r);
17034 }
17035
17036 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
17037 {
17038         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17039         return NDR_ERR_SUCCESS;
17040 }
17041
17042 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
17043 {
17044         uint16_t v;
17045         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17046         *r = v;
17047         return NDR_ERR_SUCCESS;
17048 }
17049
17050 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
17051 {
17052         const char *val = NULL;
17053
17054         switch (r) {
17055                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
17056                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
17057                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
17058                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
17059                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
17060                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
17061                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
17062                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
17063                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
17064                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17065                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
17066                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
17067                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17068                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
17069                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
17070                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
17071                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
17072                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
17073                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
17074                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
17075                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
17076                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
17077                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
17078                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
17079                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
17080                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
17081                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
17082                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
17083         }
17084         ndr_print_enum(ndr, name, "ENUM", val, r);
17085 }
17086
17087 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17088 {
17089         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17090         return NDR_ERR_SUCCESS;
17091 }
17092
17093 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17094 {
17095         uint16_t v;
17096         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17097         *r = v;
17098         return NDR_ERR_SUCCESS;
17099 }
17100
17101 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17102 {
17103         const char *val = NULL;
17104
17105         switch (r) {
17106                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17107                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17108         }
17109         ndr_print_enum(ndr, name, "ENUM", val, r);
17110 }
17111
17112 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
17113 {
17114         if (ndr_flags & NDR_SCALARS) {
17115                 int level = ndr_push_get_switch_value(ndr, r);
17116                 switch (level) {
17117                         case PRINTER_NOTIFY_TYPE: {
17118                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17119                         break; }
17120
17121                         case JOB_NOTIFY_TYPE: {
17122                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17123                         break; }
17124
17125                         default: {
17126                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17127                         break; }
17128
17129                 }
17130         }
17131         if (ndr_flags & NDR_BUFFERS) {
17132                 int level = ndr_push_get_switch_value(ndr, r);
17133                 switch (level) {
17134                         case PRINTER_NOTIFY_TYPE:
17135                         break;
17136
17137                         case JOB_NOTIFY_TYPE:
17138                         break;
17139
17140                         default:
17141                         break;
17142
17143                 }
17144         }
17145         return NDR_ERR_SUCCESS;
17146 }
17147
17148 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
17149 {
17150         int level;
17151         level = ndr_pull_get_switch_value(ndr, r);
17152         if (ndr_flags & NDR_SCALARS) {
17153                 switch (level) {
17154                         case PRINTER_NOTIFY_TYPE: {
17155                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17156                         break; }
17157
17158                         case JOB_NOTIFY_TYPE: {
17159                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17160                         break; }
17161
17162                         default: {
17163                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17164                         break; }
17165
17166                 }
17167         }
17168         if (ndr_flags & NDR_BUFFERS) {
17169                 switch (level) {
17170                         case PRINTER_NOTIFY_TYPE:
17171                         break;
17172
17173                         case JOB_NOTIFY_TYPE:
17174                         break;
17175
17176                         default:
17177                         break;
17178
17179                 }
17180         }
17181         return NDR_ERR_SUCCESS;
17182 }
17183
17184 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17185 {
17186         uint32_t cntr_fields_1;
17187         if (ndr_flags & NDR_SCALARS) {
17188                 NDR_CHECK(ndr_push_align(ndr, 4));
17189                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17190                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17194                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17195         }
17196         if (ndr_flags & NDR_BUFFERS) {
17197                 if (r->fields) {
17198                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17199                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17200                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17201                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17202                         }
17203                 }
17204         }
17205         return NDR_ERR_SUCCESS;
17206 }
17207
17208 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17209 {
17210         uint32_t _ptr_fields;
17211         uint32_t cntr_fields_1;
17212         TALLOC_CTX *_mem_save_fields_0;
17213         TALLOC_CTX *_mem_save_fields_1;
17214         if (ndr_flags & NDR_SCALARS) {
17215                 NDR_CHECK(ndr_pull_align(ndr, 4));
17216                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17217                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17218                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17219                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17221                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17222                 if (_ptr_fields) {
17223                         NDR_PULL_ALLOC(ndr, r->fields);
17224                 } else {
17225                         r->fields = NULL;
17226                 }
17227         }
17228         if (ndr_flags & NDR_BUFFERS) {
17229                 if (r->fields) {
17230                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17231                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17233                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17234                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17235                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17236                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17237                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17238                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17239                         }
17240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17241                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17242                 }
17243                 if (r->fields) {
17244                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17245                 }
17246         }
17247         return NDR_ERR_SUCCESS;
17248 }
17249
17250 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17251 {
17252         uint32_t cntr_fields_1;
17253         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17254         ndr->depth++;
17255         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17256         ndr_print_uint16(ndr, "u1", r->u1);
17257         ndr_print_uint32(ndr, "u2", r->u2);
17258         ndr_print_uint32(ndr, "u3", r->u3);
17259         ndr_print_uint32(ndr, "count", r->count);
17260         ndr_print_ptr(ndr, "fields", r->fields);
17261         ndr->depth++;
17262         if (r->fields) {
17263                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17264                 ndr->depth++;
17265                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17266                         char *idx_1=NULL;
17267                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17268                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
17269                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
17270                                 free(idx_1);
17271                         }
17272                 }
17273                 ndr->depth--;
17274         }
17275         ndr->depth--;
17276         ndr->depth--;
17277 }
17278
17279 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17280 {
17281         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17282         return NDR_ERR_SUCCESS;
17283 }
17284
17285 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17286 {
17287         uint32_t v;
17288         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17289         *r = v;
17290         return NDR_ERR_SUCCESS;
17291 }
17292
17293 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17294 {
17295         ndr_print_uint32(ndr, name, r);
17296         ndr->depth++;
17297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17298         ndr->depth--;
17299 }
17300
17301 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17302 {
17303         uint32_t cntr_types_1;
17304         if (ndr_flags & NDR_SCALARS) {
17305                 NDR_CHECK(ndr_push_align(ndr, 4));
17306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17307                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17308                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17309                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17310         }
17311         if (ndr_flags & NDR_BUFFERS) {
17312                 if (r->types) {
17313                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17314                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17315                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17316                         }
17317                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17318                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17319                         }
17320                 }
17321         }
17322         return NDR_ERR_SUCCESS;
17323 }
17324
17325 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17326 {
17327         uint32_t _ptr_types;
17328         uint32_t cntr_types_1;
17329         TALLOC_CTX *_mem_save_types_0;
17330         TALLOC_CTX *_mem_save_types_1;
17331         if (ndr_flags & NDR_SCALARS) {
17332                 NDR_CHECK(ndr_pull_align(ndr, 4));
17333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17334                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17335                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17336                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17337                 if (_ptr_types) {
17338                         NDR_PULL_ALLOC(ndr, r->types);
17339                 } else {
17340                         r->types = NULL;
17341                 }
17342         }
17343         if (ndr_flags & NDR_BUFFERS) {
17344                 if (r->types) {
17345                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17346                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17347                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17348                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17349                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17350                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17351                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17352                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17353                         }
17354                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17355                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17356                         }
17357                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17358                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17359                 }
17360                 if (r->types) {
17361                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17362                 }
17363         }
17364         return NDR_ERR_SUCCESS;
17365 }
17366
17367 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17368 {
17369         uint32_t cntr_types_1;
17370         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17371         ndr->depth++;
17372         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17373         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17374         ndr_print_uint32(ndr, "count", r->count);
17375         ndr_print_ptr(ndr, "types", r->types);
17376         ndr->depth++;
17377         if (r->types) {
17378                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17379                 ndr->depth++;
17380                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17381                         char *idx_1=NULL;
17382                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17383                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17384                                 free(idx_1);
17385                         }
17386                 }
17387                 ndr->depth--;
17388         }
17389         ndr->depth--;
17390         ndr->depth--;
17391 }
17392
17393 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17394 {
17395         if (ndr_flags & NDR_SCALARS) {
17396                 NDR_CHECK(ndr_push_align(ndr, 4));
17397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17399         }
17400         if (ndr_flags & NDR_BUFFERS) {
17401                 if (r->string) {
17402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17403                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17404                 }
17405         }
17406         return NDR_ERR_SUCCESS;
17407 }
17408
17409 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17410 {
17411         uint32_t _ptr_string;
17412         TALLOC_CTX *_mem_save_string_0;
17413         if (ndr_flags & NDR_SCALARS) {
17414                 NDR_CHECK(ndr_pull_align(ndr, 4));
17415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17417                 if (_ptr_string) {
17418                         NDR_PULL_ALLOC(ndr, r->string);
17419                 } else {
17420                         r->string = NULL;
17421                 }
17422         }
17423         if (ndr_flags & NDR_BUFFERS) {
17424                 if (r->string) {
17425                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17426                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17427                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17428                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17429                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17430                 }
17431                 if (r->string) {
17432                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17433                 }
17434         }
17435         return NDR_ERR_SUCCESS;
17436 }
17437
17438 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17439 {
17440         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17441         ndr->depth++;
17442         ndr_print_uint32(ndr, "size", r->size);
17443         ndr_print_ptr(ndr, "string", r->string);
17444         ndr->depth++;
17445         if (r->string) {
17446                 ndr_print_string(ndr, "string", r->string);
17447         }
17448         ndr->depth--;
17449         ndr->depth--;
17450 }
17451
17452 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17453 {
17454         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17455         return NDR_ERR_SUCCESS;
17456 }
17457
17458 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17459 {
17460         uint32_t v;
17461         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17462         *r = v;
17463         return NDR_ERR_SUCCESS;
17464 }
17465
17466 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17467 {
17468         const char *val = NULL;
17469
17470         switch (r) {
17471                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17472                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17473                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17474                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17475                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17476         }
17477         ndr_print_enum(ndr, name, "ENUM", val, r);
17478 }
17479
17480 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17481 {
17482         if (ndr_flags & NDR_SCALARS) {
17483                 int level = ndr_push_get_switch_value(ndr, r);
17484                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17485                 switch (level) {
17486                         case 1: {
17487                                 uint32_t cntr_integer_0;
17488                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17489                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17490                                 }
17491                         break; }
17492
17493                         case 2: {
17494                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17495                         break; }
17496
17497                         case 3: {
17498                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17499                         break; }
17500
17501                         case 4: {
17502                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17503                         break; }
17504
17505                         case 5: {
17506                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17507                         break; }
17508
17509                         default:
17510                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17511                 }
17512         }
17513         if (ndr_flags & NDR_BUFFERS) {
17514                 int level = ndr_push_get_switch_value(ndr, r);
17515                 switch (level) {
17516                         case 1:
17517                         break;
17518
17519                         case 2:
17520                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17521                         break;
17522
17523                         case 3:
17524                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17525                         break;
17526
17527                         case 4:
17528                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17529                         break;
17530
17531                         case 5:
17532                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17533                         break;
17534
17535                         default:
17536                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17537                 }
17538         }
17539         return NDR_ERR_SUCCESS;
17540 }
17541
17542 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17543 {
17544         int level;
17545         uint32_t _level;
17546         level = ndr_pull_get_switch_value(ndr, r);
17547         if (ndr_flags & NDR_SCALARS) {
17548                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17549                 if (_level != level) {
17550                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17551                 }
17552                 switch (level) {
17553                         case 1: {
17554                                 uint32_t cntr_integer_0;
17555                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17556                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17557                                 }
17558                         break; }
17559
17560                         case 2: {
17561                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17562                         break; }
17563
17564                         case 3: {
17565                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17566                         break; }
17567
17568                         case 4: {
17569                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17570                         break; }
17571
17572                         case 5: {
17573                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17574                         break; }
17575
17576                         default:
17577                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17578                 }
17579         }
17580         if (ndr_flags & NDR_BUFFERS) {
17581                 switch (level) {
17582                         case 1:
17583                         break;
17584
17585                         case 2:
17586                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17587                         break;
17588
17589                         case 3:
17590                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17591                         break;
17592
17593                         case 4:
17594                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17595                         break;
17596
17597                         case 5:
17598                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17599                         break;
17600
17601                         default:
17602                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17603                 }
17604         }
17605         return NDR_ERR_SUCCESS;
17606 }
17607
17608 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17609 {
17610         int level;
17611         uint32_t cntr_integer_0;
17612         level = ndr_print_get_switch_value(ndr, r);
17613         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17614         switch (level) {
17615                 case 1:
17616                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17617                         ndr->depth++;
17618                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17619                                 char *idx_0=NULL;
17620                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17621                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17622                                         free(idx_0);
17623                                 }
17624                         }
17625                         ndr->depth--;
17626                 break;
17627
17628                 case 2:
17629                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17630                 break;
17631
17632                 case 3:
17633                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17634                 break;
17635
17636                 case 4:
17637                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17638                 break;
17639
17640                 case 5:
17641                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17642                 break;
17643
17644                 default:
17645                         ndr_print_bad_level(ndr, name, level);
17646         }
17647 }
17648
17649 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17650 {
17651         if (ndr_flags & NDR_SCALARS) {
17652                 NDR_CHECK(ndr_push_align(ndr, 4));
17653                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17654                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
17655                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17656                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17658                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17659                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17660         }
17661         if (ndr_flags & NDR_BUFFERS) {
17662                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17663         }
17664         return NDR_ERR_SUCCESS;
17665 }
17666
17667 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17668 {
17669         if (ndr_flags & NDR_SCALARS) {
17670                 NDR_CHECK(ndr_pull_align(ndr, 4));
17671                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17672                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
17673                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17674                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17676                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17677                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17678         }
17679         if (ndr_flags & NDR_BUFFERS) {
17680                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17681         }
17682         return NDR_ERR_SUCCESS;
17683 }
17684
17685 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17686 {
17687         ndr_print_struct(ndr, name, "spoolss_Notify");
17688         ndr->depth++;
17689         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17690         ndr_print_set_switch_value(ndr, &r->field, r->type);
17691         ndr_print_spoolss_Field(ndr, "field", &r->field);
17692         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17693         ndr_print_uint32(ndr, "job_id", r->job_id);
17694         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17695         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17696         ndr->depth--;
17697 }
17698
17699 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17700 {
17701         uint32_t cntr_notifies_0;
17702         if (ndr_flags & NDR_SCALARS) {
17703                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17704                 NDR_CHECK(ndr_push_align(ndr, 4));
17705                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17707                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17708                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17709                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17710                 }
17711         }
17712         if (ndr_flags & NDR_BUFFERS) {
17713                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17714                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17715                 }
17716         }
17717         return NDR_ERR_SUCCESS;
17718 }
17719
17720 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17721 {
17722         uint32_t cntr_notifies_0;
17723         TALLOC_CTX *_mem_save_notifies_0;
17724         if (ndr_flags & NDR_SCALARS) {
17725                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17726                 NDR_CHECK(ndr_pull_align(ndr, 4));
17727                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17729                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17730                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17731                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17732                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17733                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17734                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17735                 }
17736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17737                 if (r->notifies) {
17738                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17739                 }
17740         }
17741         if (ndr_flags & NDR_BUFFERS) {
17742                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17743                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17744                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17745                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17746                 }
17747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17748         }
17749         return NDR_ERR_SUCCESS;
17750 }
17751
17752 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17753 {
17754         uint32_t cntr_notifies_0;
17755         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17756         ndr->depth++;
17757         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17758         ndr_print_uint32(ndr, "flags", r->flags);
17759         ndr_print_uint32(ndr, "count", r->count);
17760         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17761         ndr->depth++;
17762         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17763                 char *idx_0=NULL;
17764                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17765                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17766                         free(idx_0);
17767                 }
17768         }
17769         ndr->depth--;
17770         ndr->depth--;
17771 }
17772
17773 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17774 {
17775         if (ndr_flags & NDR_SCALARS) {
17776                 int level = ndr_push_get_switch_value(ndr, r);
17777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17778                 switch (level) {
17779                         case 0: {
17780                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17781                         break; }
17782
17783                         default:
17784                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17785                 }
17786         }
17787         if (ndr_flags & NDR_BUFFERS) {
17788                 int level = ndr_push_get_switch_value(ndr, r);
17789                 switch (level) {
17790                         case 0:
17791                                 if (r->info0) {
17792                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17793                                 }
17794                         break;
17795
17796                         default:
17797                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17798                 }
17799         }
17800         return NDR_ERR_SUCCESS;
17801 }
17802
17803 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17804 {
17805         int level;
17806         uint32_t _level;
17807         TALLOC_CTX *_mem_save_info0_0;
17808         level = ndr_pull_get_switch_value(ndr, r);
17809         if (ndr_flags & NDR_SCALARS) {
17810                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17811                 if (_level != level) {
17812                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17813                 }
17814                 switch (level) {
17815                         case 0: {
17816                                 uint32_t _ptr_info0;
17817                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17818                                 if (_ptr_info0) {
17819                                         NDR_PULL_ALLOC(ndr, r->info0);
17820                                 } else {
17821                                         r->info0 = NULL;
17822                                 }
17823                         break; }
17824
17825                         default:
17826                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17827                 }
17828         }
17829         if (ndr_flags & NDR_BUFFERS) {
17830                 switch (level) {
17831                         case 0:
17832                                 if (r->info0) {
17833                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17834                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17835                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17836                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17837                                 }
17838                         break;
17839
17840                         default:
17841                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17842                 }
17843         }
17844         return NDR_ERR_SUCCESS;
17845 }
17846
17847 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17848 {
17849         int level;
17850         level = ndr_print_get_switch_value(ndr, r);
17851         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17852         switch (level) {
17853                 case 0:
17854                         ndr_print_ptr(ndr, "info0", r->info0);
17855                         ndr->depth++;
17856                         if (r->info0) {
17857                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17858                         }
17859                         ndr->depth--;
17860                 break;
17861
17862                 default:
17863                         ndr_print_bad_level(ndr, name, level);
17864         }
17865 }
17866
17867 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17868 {
17869         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17870         return NDR_ERR_SUCCESS;
17871 }
17872
17873 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17874 {
17875         uint32_t v;
17876         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17877         *r = v;
17878         return NDR_ERR_SUCCESS;
17879 }
17880
17881 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17882 {
17883         ndr_print_uint32(ndr, name, r);
17884         ndr->depth++;
17885         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17886         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17887         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17888         ndr->depth--;
17889 }
17890
17891 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17892 {
17893         if (ndr_flags & NDR_SCALARS) {
17894                 NDR_CHECK(ndr_push_align(ndr, 4));
17895                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17896                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17898                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17899                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17900                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17901                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17902         }
17903         if (ndr_flags & NDR_BUFFERS) {
17904                 if (r->client) {
17905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17908                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17909                 }
17910                 if (r->user) {
17911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17912                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17913                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17914                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17915                 }
17916         }
17917         return NDR_ERR_SUCCESS;
17918 }
17919
17920 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17921 {
17922         uint32_t _ptr_client;
17923         TALLOC_CTX *_mem_save_client_0;
17924         uint32_t _ptr_user;
17925         TALLOC_CTX *_mem_save_user_0;
17926         if (ndr_flags & NDR_SCALARS) {
17927                 NDR_CHECK(ndr_pull_align(ndr, 4));
17928                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17930                 if (_ptr_client) {
17931                         NDR_PULL_ALLOC(ndr, r->client);
17932                 } else {
17933                         r->client = NULL;
17934                 }
17935                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17936                 if (_ptr_user) {
17937                         NDR_PULL_ALLOC(ndr, r->user);
17938                 } else {
17939                         r->user = NULL;
17940                 }
17941                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17942                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17943                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17944                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17945         }
17946         if (ndr_flags & NDR_BUFFERS) {
17947                 if (r->client) {
17948                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17949                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17950                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17951                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17952                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17953                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
17954                         }
17955                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17956                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17957                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17958                 }
17959                 if (r->user) {
17960                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17961                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17962                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17963                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17964                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17965                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
17966                         }
17967                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17968                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17969                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17970                 }
17971         }
17972         return NDR_ERR_SUCCESS;
17973 }
17974
17975 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17976 {
17977         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17978         ndr->depth++;
17979         ndr_print_uint32(ndr, "size", r->size);
17980         ndr_print_ptr(ndr, "client", r->client);
17981         ndr->depth++;
17982         if (r->client) {
17983                 ndr_print_string(ndr, "client", r->client);
17984         }
17985         ndr->depth--;
17986         ndr_print_ptr(ndr, "user", r->user);
17987         ndr->depth++;
17988         if (r->user) {
17989                 ndr_print_string(ndr, "user", r->user);
17990         }
17991         ndr->depth--;
17992         ndr_print_uint32(ndr, "build", r->build);
17993         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17994         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17995         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17996         ndr->depth--;
17997 }
17998
17999 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
18000 {
18001         if (ndr_flags & NDR_SCALARS) {
18002                 NDR_CHECK(ndr_push_align(ndr, 4));
18003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
18004         }
18005         if (ndr_flags & NDR_BUFFERS) {
18006         }
18007         return NDR_ERR_SUCCESS;
18008 }
18009
18010 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
18011 {
18012         if (ndr_flags & NDR_SCALARS) {
18013                 NDR_CHECK(ndr_pull_align(ndr, 4));
18014                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
18015         }
18016         if (ndr_flags & NDR_BUFFERS) {
18017         }
18018         return NDR_ERR_SUCCESS;
18019 }
18020
18021 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
18022 {
18023         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
18024         ndr->depth++;
18025         ndr_print_uint32(ndr, "not_used", r->not_used);
18026         ndr->depth--;
18027 }
18028
18029 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
18030 {
18031         if (ndr_flags & NDR_SCALARS) {
18032                 NDR_CHECK(ndr_push_align(ndr, 4));
18033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
18036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18037                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18038                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18039                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18040                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18041                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18042                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
18043         }
18044         if (ndr_flags & NDR_BUFFERS) {
18045                 if (r->client) {
18046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18049                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18050                 }
18051                 if (r->user) {
18052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18055                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18056                 }
18057         }
18058         return NDR_ERR_SUCCESS;
18059 }
18060
18061 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
18062 {
18063         uint32_t _ptr_client;
18064         TALLOC_CTX *_mem_save_client_0;
18065         uint32_t _ptr_user;
18066         TALLOC_CTX *_mem_save_user_0;
18067         if (ndr_flags & NDR_SCALARS) {
18068                 NDR_CHECK(ndr_pull_align(ndr, 4));
18069                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18070                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18071                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
18072                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18073                 if (_ptr_client) {
18074                         NDR_PULL_ALLOC(ndr, r->client);
18075                 } else {
18076                         r->client = NULL;
18077                 }
18078                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18079                 if (_ptr_user) {
18080                         NDR_PULL_ALLOC(ndr, r->user);
18081                 } else {
18082                         r->user = NULL;
18083                 }
18084                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18085                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18086                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18087                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18088                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
18089         }
18090         if (ndr_flags & NDR_BUFFERS) {
18091                 if (r->client) {
18092                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18093                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18094                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18095                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18096                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18097                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->client), ndr_get_array_length(ndr, &r->client));
18098                         }
18099                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18100                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18101                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18102                 }
18103                 if (r->user) {
18104                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18105                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18106                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18107                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18108                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18109                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->user), ndr_get_array_length(ndr, &r->user));
18110                         }
18111                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18112                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18113                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18114                 }
18115         }
18116         return NDR_ERR_SUCCESS;
18117 }
18118
18119 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
18120 {
18121         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
18122         ndr->depth++;
18123         ndr_print_uint32(ndr, "size", r->size);
18124         ndr_print_uint32(ndr, "flags", r->flags);
18125         ndr_print_uint32(ndr, "size2", r->size2);
18126         ndr_print_ptr(ndr, "client", r->client);
18127         ndr->depth++;
18128         if (r->client) {
18129                 ndr_print_string(ndr, "client", r->client);
18130         }
18131         ndr->depth--;
18132         ndr_print_ptr(ndr, "user", r->user);
18133         ndr->depth++;
18134         if (r->user) {
18135                 ndr_print_string(ndr, "user", r->user);
18136         }
18137         ndr->depth--;
18138         ndr_print_uint32(ndr, "build", r->build);
18139         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18140         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18141         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18142         ndr_print_udlong(ndr, "reserved", r->reserved);
18143         ndr->depth--;
18144 }
18145
18146 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18147 {
18148         if (ndr_flags & NDR_SCALARS) {
18149                 int level = ndr_push_get_switch_value(ndr, r);
18150                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18151                 switch (level) {
18152                         case 1: {
18153                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18154                         break; }
18155
18156                         case 2: {
18157                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18158                         break; }
18159
18160                         case 3: {
18161                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18162                         break; }
18163
18164                         default:
18165                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18166                 }
18167         }
18168         if (ndr_flags & NDR_BUFFERS) {
18169                 int level = ndr_push_get_switch_value(ndr, r);
18170                 switch (level) {
18171                         case 1:
18172                                 if (r->level1) {
18173                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18174                                 }
18175                         break;
18176
18177                         case 2:
18178                                 if (r->level2) {
18179                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18180                                 }
18181                         break;
18182
18183                         case 3:
18184                                 if (r->level3) {
18185                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18186                                 }
18187                         break;
18188
18189                         default:
18190                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18191                 }
18192         }
18193         return NDR_ERR_SUCCESS;
18194 }
18195
18196 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18197 {
18198         int level;
18199         uint32_t _level;
18200         TALLOC_CTX *_mem_save_level1_0;
18201         TALLOC_CTX *_mem_save_level2_0;
18202         TALLOC_CTX *_mem_save_level3_0;
18203         level = ndr_pull_get_switch_value(ndr, r);
18204         if (ndr_flags & NDR_SCALARS) {
18205                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18206                 if (_level != level) {
18207                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18208                 }
18209                 switch (level) {
18210                         case 1: {
18211                                 uint32_t _ptr_level1;
18212                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18213                                 if (_ptr_level1) {
18214                                         NDR_PULL_ALLOC(ndr, r->level1);
18215                                 } else {
18216                                         r->level1 = NULL;
18217                                 }
18218                         break; }
18219
18220                         case 2: {
18221                                 uint32_t _ptr_level2;
18222                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18223                                 if (_ptr_level2) {
18224                                         NDR_PULL_ALLOC(ndr, r->level2);
18225                                 } else {
18226                                         r->level2 = NULL;
18227                                 }
18228                         break; }
18229
18230                         case 3: {
18231                                 uint32_t _ptr_level3;
18232                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18233                                 if (_ptr_level3) {
18234                                         NDR_PULL_ALLOC(ndr, r->level3);
18235                                 } else {
18236                                         r->level3 = NULL;
18237                                 }
18238                         break; }
18239
18240                         default:
18241                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18242                 }
18243         }
18244         if (ndr_flags & NDR_BUFFERS) {
18245                 switch (level) {
18246                         case 1:
18247                                 if (r->level1) {
18248                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18249                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18250                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18251                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18252                                 }
18253                         break;
18254
18255                         case 2:
18256                                 if (r->level2) {
18257                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18258                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18259                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18260                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18261                                 }
18262                         break;
18263
18264                         case 3:
18265                                 if (r->level3) {
18266                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18267                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18268                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18269                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18270                                 }
18271                         break;
18272
18273                         default:
18274                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18275                 }
18276         }
18277         return NDR_ERR_SUCCESS;
18278 }
18279
18280 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18281 {
18282         int level;
18283         level = ndr_print_get_switch_value(ndr, r);
18284         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18285         switch (level) {
18286                 case 1:
18287                         ndr_print_ptr(ndr, "level1", r->level1);
18288                         ndr->depth++;
18289                         if (r->level1) {
18290                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18291                         }
18292                         ndr->depth--;
18293                 break;
18294
18295                 case 2:
18296                         ndr_print_ptr(ndr, "level2", r->level2);
18297                         ndr->depth++;
18298                         if (r->level2) {
18299                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18300                         }
18301                         ndr->depth--;
18302                 break;
18303
18304                 case 3:
18305                         ndr_print_ptr(ndr, "level3", r->level3);
18306                         ndr->depth++;
18307                         if (r->level3) {
18308                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18309                         }
18310                         ndr->depth--;
18311                 break;
18312
18313                 default:
18314                         ndr_print_bad_level(ndr, name, level);
18315         }
18316 }
18317
18318 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18319 {
18320         if (ndr_flags & NDR_SCALARS) {
18321                 NDR_CHECK(ndr_push_align(ndr, 4));
18322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18323                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18324                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18325         }
18326         if (ndr_flags & NDR_BUFFERS) {
18327                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18328         }
18329         return NDR_ERR_SUCCESS;
18330 }
18331
18332 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18333 {
18334         if (ndr_flags & NDR_SCALARS) {
18335                 NDR_CHECK(ndr_pull_align(ndr, 4));
18336                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18337                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18338                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18339         }
18340         if (ndr_flags & NDR_BUFFERS) {
18341                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18342         }
18343         return NDR_ERR_SUCCESS;
18344 }
18345
18346 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18347 {
18348         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18349         ndr->depth++;
18350         ndr_print_uint32(ndr, "level", r->level);
18351         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18352         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18353         ndr->depth--;
18354 }
18355
18356 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18357 {
18358         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18359         return NDR_ERR_SUCCESS;
18360 }
18361
18362 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18363 {
18364         uint32_t v;
18365         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18366         *r = v;
18367         return NDR_ERR_SUCCESS;
18368 }
18369
18370 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18371 {
18372         ndr_print_uint32(ndr, name, r);
18373         ndr->depth++;
18374         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18375         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18376         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18377         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18378         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18379         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18380         ndr->depth--;
18381 }
18382
18383 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
18384 {
18385         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18386         if (ndr_flags & NDR_SCALARS) {
18387                 NDR_CHECK(ndr_push_align(ndr, 4));
18388                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18389                 {
18390                         uint32_t _flags_save_string = ndr->flags;
18391                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18392                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
18393                         ndr->flags = _flags_save_string;
18394                 }
18395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
18396                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
18397                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
18398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
18399         }
18400         if (ndr_flags & NDR_BUFFERS) {
18401                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18402                 {
18403                         uint32_t _flags_save_string = ndr->flags;
18404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18405                         if (r->value_name) {
18406                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
18407                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
18408                         }
18409                         ndr->flags = _flags_save_string;
18410                 }
18411                 if (r->data) {
18412                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
18413                         {
18414                                 struct ndr_push *_ndr_data;
18415                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18416                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
18417                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18418                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18419                         }
18420                 }
18421         }
18422         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18423         return NDR_ERR_SUCCESS;
18424 }
18425
18426 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
18427 {
18428         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18429         uint32_t _ptr_value_name;
18430         TALLOC_CTX *_mem_save_value_name_0;
18431         uint32_t _ptr_data;
18432         TALLOC_CTX *_mem_save_data_0;
18433         if (ndr_flags & NDR_SCALARS) {
18434                 NDR_CHECK(ndr_pull_align(ndr, 4));
18435                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18436                 {
18437                         uint32_t _flags_save_string = ndr->flags;
18438                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18439                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
18440                         if (_ptr_value_name) {
18441                                 NDR_PULL_ALLOC(ndr, r->value_name);
18442                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
18443                         } else {
18444                                 r->value_name = NULL;
18445                         }
18446                         ndr->flags = _flags_save_string;
18447                 }
18448                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
18449                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
18450                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
18451                 if (_ptr_data) {
18452                         NDR_PULL_ALLOC(ndr, r->data);
18453                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
18454                 } else {
18455                         r->data = NULL;
18456                 }
18457                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
18458         }
18459         if (ndr_flags & NDR_BUFFERS) {
18460                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18461                 {
18462                         uint32_t _flags_save_string = ndr->flags;
18463                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18464                         if (r->value_name) {
18465                                 uint32_t _relative_save_offset;
18466                                 _relative_save_offset = ndr->offset;
18467                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
18468                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18469                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
18470                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
18471                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
18472                                 ndr->offset = _relative_save_offset;
18473                         }
18474                         ndr->flags = _flags_save_string;
18475                 }
18476                 if (r->data) {
18477                         uint32_t _relative_save_offset;
18478                         _relative_save_offset = ndr->offset;
18479                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
18480                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
18481                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
18482                         {
18483                                 struct ndr_pull *_ndr_data;
18484                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18485                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
18486                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18487                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18488                         }
18489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
18490                         ndr->offset = _relative_save_offset;
18491                 }
18492         }
18493         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18494         return NDR_ERR_SUCCESS;
18495 }
18496
18497 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
18498 {
18499         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
18500         ndr->depth++;
18501         ndr_print_ptr(ndr, "value_name", r->value_name);
18502         ndr->depth++;
18503         if (r->value_name) {
18504                 ndr_print_string(ndr, "value_name", r->value_name);
18505         }
18506         ndr->depth--;
18507         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
18508         ndr_print_winreg_Type(ndr, "type", r->type);
18509         ndr_print_ptr(ndr, "data", r->data);
18510         ndr->depth++;
18511         if (r->data) {
18512                 ndr_print_set_switch_value(ndr, r->data, r->type);
18513                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
18514         }
18515         ndr->depth--;
18516         ndr_print_uint32(ndr, "data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags):r->data_length);
18517         ndr->depth--;
18518 }
18519
18520 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
18521 {
18522         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
18523 }
18524
18525 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18526 {
18527         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18528         return NDR_ERR_SUCCESS;
18529 }
18530
18531 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18532 {
18533         uint32_t v;
18534         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18535         *r = v;
18536         return NDR_ERR_SUCCESS;
18537 }
18538
18539 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18540 {
18541         ndr_print_uint32(ndr, name, r);
18542         ndr->depth++;
18543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18546         ndr->depth--;
18547 }
18548
18549 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18550 {
18551         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18552         return NDR_ERR_SUCCESS;
18553 }
18554
18555 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18556 {
18557         uint32_t v;
18558         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18559         *r = v;
18560         return NDR_ERR_SUCCESS;
18561 }
18562
18563 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18564 {
18565         const char *val = NULL;
18566
18567         switch (r) {
18568                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18569                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18570         }
18571         ndr_print_enum(ndr, name, "ENUM", val, r);
18572 }
18573
18574 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18575 {
18576         if (ndr_flags & NDR_SCALARS) {
18577                 NDR_CHECK(ndr_push_align(ndr, 4));
18578                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18579                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18580                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18581                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18583                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18584                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18585                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18586                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18587                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18588                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18589                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18590                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18593         }
18594         if (ndr_flags & NDR_BUFFERS) {
18595         }
18596         return NDR_ERR_SUCCESS;
18597 }
18598
18599 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18600 {
18601         if (ndr_flags & NDR_SCALARS) {
18602                 NDR_CHECK(ndr_pull_align(ndr, 4));
18603                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18604                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18605                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18606                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18607                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18608                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18609                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18610                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18611                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18612                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18613                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18614                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18615                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18617                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18618         }
18619         if (ndr_flags & NDR_BUFFERS) {
18620         }
18621         return NDR_ERR_SUCCESS;
18622 }
18623
18624 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18625 {
18626         ndr_print_struct(ndr, name, "spoolss_PortData1");
18627         ndr->depth++;
18628         ndr_print_string(ndr, "portname", r->portname);
18629         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18630         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18631         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18632         ndr_print_uint32(ndr, "reserved", r->reserved);
18633         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18634         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18635         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18636         ndr_print_string(ndr, "queue", r->queue);
18637         ndr_print_string(ndr, "ip_address", r->ip_address);
18638         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18639         ndr_print_string(ndr, "device_type", r->device_type);
18640         ndr_print_uint32(ndr, "port_number", r->port_number);
18641         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18642         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18643         ndr->depth--;
18644 }
18645
18646 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18647 {
18648         if (ndr_flags & NDR_SCALARS) {
18649                 NDR_CHECK(ndr_push_align(ndr, 4));
18650                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18651                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18652                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18653                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18654                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18655                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18656                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18658                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18659                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18663                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18664         }
18665         if (ndr_flags & NDR_BUFFERS) {
18666         }
18667         return NDR_ERR_SUCCESS;
18668 }
18669
18670 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18671 {
18672         if (ndr_flags & NDR_SCALARS) {
18673                 NDR_CHECK(ndr_pull_align(ndr, 4));
18674                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18675                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18676                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18677                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18679                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18680                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18681                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18682                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18683                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18684                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18685                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18686                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18688         }
18689         if (ndr_flags & NDR_BUFFERS) {
18690         }
18691         return NDR_ERR_SUCCESS;
18692 }
18693
18694 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18695 {
18696         ndr_print_struct(ndr, name, "spoolss_PortData2");
18697         ndr->depth++;
18698         ndr_print_string(ndr, "portname", r->portname);
18699         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18700         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18701         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18702         ndr_print_uint32(ndr, "reserved", r->reserved);
18703         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18704         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18705         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18706         ndr_print_string(ndr, "queue", r->queue);
18707         ndr_print_string(ndr, "device_type", r->device_type);
18708         ndr_print_uint32(ndr, "port_number", r->port_number);
18709         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18710         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18711         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18712         ndr->depth--;
18713 }
18714
18715 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18716 {
18717         if (ndr_flags & NDR_SCALARS) {
18718                 NDR_CHECK(ndr_push_align(ndr, 4));
18719                 {
18720                         uint32_t _flags_save_string = ndr->flags;
18721                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18722                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18723                         ndr->flags = _flags_save_string;
18724                 }
18725         }
18726         if (ndr_flags & NDR_BUFFERS) {
18727         }
18728         return NDR_ERR_SUCCESS;
18729 }
18730
18731 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18732 {
18733         if (ndr_flags & NDR_SCALARS) {
18734                 NDR_CHECK(ndr_pull_align(ndr, 4));
18735                 {
18736                         uint32_t _flags_save_string = ndr->flags;
18737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18738                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18739                         ndr->flags = _flags_save_string;
18740                 }
18741         }
18742         if (ndr_flags & NDR_BUFFERS) {
18743         }
18744         return NDR_ERR_SUCCESS;
18745 }
18746
18747 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18748 {
18749         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18750         ndr->depth++;
18751         ndr_print_string(ndr, "dll_name", r->dll_name);
18752         ndr->depth--;
18753 }
18754
18755 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18756 {
18757         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18758         return NDR_ERR_SUCCESS;
18759 }
18760
18761 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18762 {
18763         uint32_t v;
18764         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18765         *r = v;
18766         return NDR_ERR_SUCCESS;
18767 }
18768
18769 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18770 {
18771         ndr_print_uint32(ndr, name, r);
18772         ndr->depth++;
18773         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18774         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18775         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18776         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18777         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18778         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18779         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18780         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18781         ndr->depth--;
18782 }
18783
18784 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18785 {
18786         if (flags & NDR_IN) {
18787                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18788                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18789                 if (r->in.server) {
18790                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18791                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18792                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18793                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18794                 }
18795                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18797                 if (r->in.buffer) {
18798                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18799                 }
18800                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18801         }
18802         if (flags & NDR_OUT) {
18803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18804                 if (r->out.info) {
18805                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18806                 }
18807                 if (r->out.needed == NULL) {
18808                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18809                 }
18810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18811                 if (r->out.count == NULL) {
18812                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18813                 }
18814                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18815                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18816         }
18817         return NDR_ERR_SUCCESS;
18818 }
18819
18820 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18821 {
18822         uint32_t _ptr_server;
18823         uint32_t _ptr_buffer;
18824         uint32_t _ptr_info;
18825         TALLOC_CTX *_mem_save_server_0;
18826         TALLOC_CTX *_mem_save_buffer_0;
18827         TALLOC_CTX *_mem_save_info_0;
18828         TALLOC_CTX *_mem_save_needed_0;
18829         TALLOC_CTX *_mem_save_count_0;
18830         if (flags & NDR_IN) {
18831                 ZERO_STRUCT(r->out);
18832
18833                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18834                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18835                 if (_ptr_server) {
18836                         NDR_PULL_ALLOC(ndr, r->in.server);
18837                 } else {
18838                         r->in.server = NULL;
18839                 }
18840                 if (r->in.server) {
18841                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18842                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18843                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18844                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18845                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18846                                 return 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));
18847                         }
18848                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18849                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18850                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18851                 }
18852                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18853                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18854                 if (_ptr_buffer) {
18855                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18856                 } else {
18857                         r->in.buffer = NULL;
18858                 }
18859                 if (r->in.buffer) {
18860                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18861                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18862                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18863                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18864                 }
18865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18866                 NDR_PULL_ALLOC(ndr, r->out.needed);
18867                 ZERO_STRUCTP(r->out.needed);
18868                 NDR_PULL_ALLOC(ndr, r->out.count);
18869                 ZERO_STRUCTP(r->out.count);
18870         }
18871         if (flags & NDR_OUT) {
18872                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18873                 if (_ptr_info) {
18874                         NDR_PULL_ALLOC(ndr, r->out.info);
18875                 } else {
18876                         r->out.info = NULL;
18877                 }
18878                 if (r->out.info) {
18879                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18880                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18881                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18882                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18883                 }
18884                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18885                         NDR_PULL_ALLOC(ndr, r->out.needed);
18886                 }
18887                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18888                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18890                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18891                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18892                         NDR_PULL_ALLOC(ndr, r->out.count);
18893                 }
18894                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18895                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18896                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18897                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18898                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18899         }
18900         return NDR_ERR_SUCCESS;
18901 }
18902
18903 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18904 {
18905         uint32_t cntr_info_0;
18906         if (flags & NDR_IN) {
18907                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18909         }
18910         if (flags & NDR_OUT) {
18911                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18912                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18913                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18914                 }
18915                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18916                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18917                 }
18918         }
18919         return NDR_ERR_SUCCESS;
18920 }
18921
18922 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18923 {
18924         uint32_t cntr_info_0;
18925         TALLOC_CTX *_mem_save_info_0;
18926         if (flags & NDR_IN) {
18927                 ZERO_STRUCT(r->out);
18928
18929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18931         }
18932         if (flags & NDR_OUT) {
18933                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18934                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18935                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18936                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18937                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18938                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18939                 }
18940                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18941                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18942                 }
18943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18944         }
18945         return NDR_ERR_SUCCESS;
18946 }
18947
18948 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18949 {
18950         uint32_t cntr_info_2;
18951         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18952         ndr->depth++;
18953         if (flags & NDR_SET_VALUES) {
18954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18955         }
18956         if (flags & NDR_IN) {
18957                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18958                 ndr->depth++;
18959                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18960                 ndr_print_ptr(ndr, "server", r->in.server);
18961                 ndr->depth++;
18962                 if (r->in.server) {
18963                         ndr_print_string(ndr, "server", r->in.server);
18964                 }
18965                 ndr->depth--;
18966                 ndr_print_uint32(ndr, "level", r->in.level);
18967                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18968                 ndr->depth++;
18969                 if (r->in.buffer) {
18970                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18971                 }
18972                 ndr->depth--;
18973                 ndr_print_uint32(ndr, "offered", r->in.offered);
18974                 ndr->depth--;
18975         }
18976         if (flags & NDR_OUT) {
18977                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18978                 ndr->depth++;
18979                 ndr_print_ptr(ndr, "count", r->out.count);
18980                 ndr->depth++;
18981                 ndr_print_uint32(ndr, "count", *r->out.count);
18982                 ndr->depth--;
18983                 ndr_print_ptr(ndr, "info", r->out.info);
18984                 ndr->depth++;
18985                 ndr_print_ptr(ndr, "info", *r->out.info);
18986                 ndr->depth++;
18987                 if (*r->out.info) {
18988                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18989                         ndr->depth++;
18990                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18991                                 char *idx_2=NULL;
18992                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18993                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18994                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18995                                         free(idx_2);
18996                                 }
18997                         }
18998                         ndr->depth--;
18999                 }
19000                 ndr->depth--;
19001                 ndr->depth--;
19002                 ndr_print_ptr(ndr, "needed", r->out.needed);
19003                 ndr->depth++;
19004                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19005                 ndr->depth--;
19006                 ndr_print_WERROR(ndr, "result", r->out.result);
19007                 ndr->depth--;
19008         }
19009         ndr->depth--;
19010 }
19011
19012 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
19013 {
19014         if (flags & NDR_IN) {
19015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
19016                 if (r->in.printername) {
19017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19019                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
19020                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19021                 }
19022                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
19023                 if (r->in.datatype) {
19024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19027                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19028                 }
19029                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19030                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
19031         }
19032         if (flags & NDR_OUT) {
19033                 if (r->out.handle == NULL) {
19034                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19035                 }
19036                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19037                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19038         }
19039         return NDR_ERR_SUCCESS;
19040 }
19041
19042 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
19043 {
19044         uint32_t _ptr_printername;
19045         uint32_t _ptr_datatype;
19046         TALLOC_CTX *_mem_save_printername_0;
19047         TALLOC_CTX *_mem_save_datatype_0;
19048         TALLOC_CTX *_mem_save_handle_0;
19049         if (flags & NDR_IN) {
19050                 ZERO_STRUCT(r->out);
19051
19052                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
19053                 if (_ptr_printername) {
19054                         NDR_PULL_ALLOC(ndr, r->in.printername);
19055                 } else {
19056                         r->in.printername = NULL;
19057                 }
19058                 if (r->in.printername) {
19059                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19060                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
19061                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
19062                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
19063                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
19064                                 return 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));
19065                         }
19066                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
19067                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
19068                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
19069                 }
19070                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
19071                 if (_ptr_datatype) {
19072                         NDR_PULL_ALLOC(ndr, r->in.datatype);
19073                 } else {
19074                         r->in.datatype = NULL;
19075                 }
19076                 if (r->in.datatype) {
19077                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
19078                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
19079                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
19080                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
19081                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
19082                                 return 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));
19083                         }
19084                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
19085                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
19086                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
19087                 }
19088                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19089                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
19090                 NDR_PULL_ALLOC(ndr, r->out.handle);
19091                 ZERO_STRUCTP(r->out.handle);
19092         }
19093         if (flags & NDR_OUT) {
19094                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19095                         NDR_PULL_ALLOC(ndr, r->out.handle);
19096                 }
19097                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19098                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19099                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19100                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19101                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19102         }
19103         return NDR_ERR_SUCCESS;
19104 }
19105
19106 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
19107 {
19108         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
19109         ndr->depth++;
19110         if (flags & NDR_SET_VALUES) {
19111                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19112         }
19113         if (flags & NDR_IN) {
19114                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
19115                 ndr->depth++;
19116                 ndr_print_ptr(ndr, "printername", r->in.printername);
19117                 ndr->depth++;
19118                 if (r->in.printername) {
19119                         ndr_print_string(ndr, "printername", r->in.printername);
19120                 }
19121                 ndr->depth--;
19122                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
19123                 ndr->depth++;
19124                 if (r->in.datatype) {
19125                         ndr_print_string(ndr, "datatype", r->in.datatype);
19126                 }
19127                 ndr->depth--;
19128                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
19129                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
19130                 ndr->depth--;
19131         }
19132         if (flags & NDR_OUT) {
19133                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
19134                 ndr->depth++;
19135                 ndr_print_ptr(ndr, "handle", r->out.handle);
19136                 ndr->depth++;
19137                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19138                 ndr->depth--;
19139                 ndr_print_WERROR(ndr, "result", r->out.result);
19140                 ndr->depth--;
19141         }
19142         ndr->depth--;
19143 }
19144
19145 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
19146 {
19147         if (flags & NDR_IN) {
19148                 if (r->in.handle == NULL) {
19149                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19150                 }
19151                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19152                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19153                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19154                 if (r->in.ctr) {
19155                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19156                 }
19157                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19158         }
19159         if (flags & NDR_OUT) {
19160                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19161         }
19162         return NDR_ERR_SUCCESS;
19163 }
19164
19165 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19166 {
19167         uint32_t _ptr_ctr;
19168         TALLOC_CTX *_mem_save_handle_0;
19169         TALLOC_CTX *_mem_save_ctr_0;
19170         if (flags & NDR_IN) {
19171                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19172                         NDR_PULL_ALLOC(ndr, r->in.handle);
19173                 }
19174                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19175                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19176                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19178                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19179                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19180                 if (_ptr_ctr) {
19181                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19182                 } else {
19183                         r->in.ctr = NULL;
19184                 }
19185                 if (r->in.ctr) {
19186                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19187                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
19188                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19189                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
19190                 }
19191                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
19192         }
19193         if (flags & NDR_OUT) {
19194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19195         }
19196         return NDR_ERR_SUCCESS;
19197 }
19198
19199 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
19200 {
19201         ndr_print_struct(ndr, name, "spoolss_SetJob");
19202         ndr->depth++;
19203         if (flags & NDR_SET_VALUES) {
19204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19205         }
19206         if (flags & NDR_IN) {
19207                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
19208                 ndr->depth++;
19209                 ndr_print_ptr(ndr, "handle", r->in.handle);
19210                 ndr->depth++;
19211                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19212                 ndr->depth--;
19213                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19214                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
19215                 ndr->depth++;
19216                 if (r->in.ctr) {
19217                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
19218                 }
19219                 ndr->depth--;
19220                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
19221                 ndr->depth--;
19222         }
19223         if (flags & NDR_OUT) {
19224                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
19225                 ndr->depth++;
19226                 ndr_print_WERROR(ndr, "result", r->out.result);
19227                 ndr->depth--;
19228         }
19229         ndr->depth--;
19230 }
19231
19232 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
19233 {
19234         if (flags & NDR_IN) {
19235                 if (r->in.handle == NULL) {
19236                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19237                 }
19238                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19241                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19242                 if (r->in.buffer) {
19243                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19244                 }
19245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19246         }
19247         if (flags & NDR_OUT) {
19248                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19249                 if (r->out.info) {
19250                         {
19251                                 struct ndr_push *_ndr_info;
19252                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19253                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19254                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19255                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19256                         }
19257                 }
19258                 if (r->out.needed == NULL) {
19259                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19260                 }
19261                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19262                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19263         }
19264         return NDR_ERR_SUCCESS;
19265 }
19266
19267 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
19268 {
19269         uint32_t _ptr_buffer;
19270         uint32_t _ptr_info;
19271         TALLOC_CTX *_mem_save_handle_0;
19272         TALLOC_CTX *_mem_save_buffer_0;
19273         TALLOC_CTX *_mem_save_info_0;
19274         TALLOC_CTX *_mem_save_needed_0;
19275         if (flags & NDR_IN) {
19276                 ZERO_STRUCT(r->out);
19277
19278                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19279                         NDR_PULL_ALLOC(ndr, r->in.handle);
19280                 }
19281                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19282                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19283                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19284                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19285                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19286                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19287                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19288                 if (_ptr_buffer) {
19289                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19290                 } else {
19291                         r->in.buffer = NULL;
19292                 }
19293                 if (r->in.buffer) {
19294                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19295                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19296                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19298                 }
19299                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19300                 NDR_PULL_ALLOC(ndr, r->out.needed);
19301                 ZERO_STRUCTP(r->out.needed);
19302         }
19303         if (flags & NDR_OUT) {
19304                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19305                 if (_ptr_info) {
19306                         NDR_PULL_ALLOC(ndr, r->out.info);
19307                 } else {
19308                         r->out.info = NULL;
19309                 }
19310                 if (r->out.info) {
19311                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19312                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19313                         {
19314                                 struct ndr_pull *_ndr_info;
19315                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19316                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19317                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19318                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19319                         }
19320                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19321                 }
19322                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19323                         NDR_PULL_ALLOC(ndr, r->out.needed);
19324                 }
19325                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19326                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19327                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19328                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19329                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19330         }
19331         return NDR_ERR_SUCCESS;
19332 }
19333
19334 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19335 {
19336         ndr_print_struct(ndr, name, "spoolss_GetJob");
19337         ndr->depth++;
19338         if (flags & NDR_SET_VALUES) {
19339                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19340         }
19341         if (flags & NDR_IN) {
19342                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19343                 ndr->depth++;
19344                 ndr_print_ptr(ndr, "handle", r->in.handle);
19345                 ndr->depth++;
19346                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19347                 ndr->depth--;
19348                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19349                 ndr_print_uint32(ndr, "level", r->in.level);
19350                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19351                 ndr->depth++;
19352                 if (r->in.buffer) {
19353                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19354                 }
19355                 ndr->depth--;
19356                 ndr_print_uint32(ndr, "offered", r->in.offered);
19357                 ndr->depth--;
19358         }
19359         if (flags & NDR_OUT) {
19360                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19361                 ndr->depth++;
19362                 ndr_print_ptr(ndr, "info", r->out.info);
19363                 ndr->depth++;
19364                 if (r->out.info) {
19365                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19366                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19367                 }
19368                 ndr->depth--;
19369                 ndr_print_ptr(ndr, "needed", r->out.needed);
19370                 ndr->depth++;
19371                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19372                 ndr->depth--;
19373                 ndr_print_WERROR(ndr, "result", r->out.result);
19374                 ndr->depth--;
19375         }
19376         ndr->depth--;
19377 }
19378
19379 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19380 {
19381         if (flags & NDR_IN) {
19382                 if (r->in.handle == NULL) {
19383                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19384                 }
19385                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19386                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19390                 if (r->in.buffer) {
19391                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19392                 }
19393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19394         }
19395         if (flags & NDR_OUT) {
19396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19397                 if (r->out.info) {
19398                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19399                 }
19400                 if (r->out.needed == NULL) {
19401                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19402                 }
19403                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19404                 if (r->out.count == NULL) {
19405                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19406                 }
19407                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19408                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19409         }
19410         return NDR_ERR_SUCCESS;
19411 }
19412
19413 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19414 {
19415         uint32_t _ptr_buffer;
19416         uint32_t _ptr_info;
19417         TALLOC_CTX *_mem_save_handle_0;
19418         TALLOC_CTX *_mem_save_buffer_0;
19419         TALLOC_CTX *_mem_save_info_0;
19420         TALLOC_CTX *_mem_save_needed_0;
19421         TALLOC_CTX *_mem_save_count_0;
19422         if (flags & NDR_IN) {
19423                 ZERO_STRUCT(r->out);
19424
19425                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19426                         NDR_PULL_ALLOC(ndr, r->in.handle);
19427                 }
19428                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19429                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19430                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19431                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19434                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19436                 if (_ptr_buffer) {
19437                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19438                 } else {
19439                         r->in.buffer = NULL;
19440                 }
19441                 if (r->in.buffer) {
19442                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19443                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19444                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19445                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19446                 }
19447                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19448                 NDR_PULL_ALLOC(ndr, r->out.needed);
19449                 ZERO_STRUCTP(r->out.needed);
19450                 NDR_PULL_ALLOC(ndr, r->out.count);
19451                 ZERO_STRUCTP(r->out.count);
19452         }
19453         if (flags & NDR_OUT) {
19454                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19455                 if (_ptr_info) {
19456                         NDR_PULL_ALLOC(ndr, r->out.info);
19457                 } else {
19458                         r->out.info = NULL;
19459                 }
19460                 if (r->out.info) {
19461                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19462                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19463                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19464                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19465                 }
19466                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19467                         NDR_PULL_ALLOC(ndr, r->out.needed);
19468                 }
19469                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19470                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19471                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19472                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19473                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19474                         NDR_PULL_ALLOC(ndr, r->out.count);
19475                 }
19476                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19477                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19479                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19480                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19481         }
19482         return NDR_ERR_SUCCESS;
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         uint32_t cntr_info_0;
19488         if (flags & NDR_IN) {
19489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19490                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19491         }
19492         if (flags & NDR_OUT) {
19493                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19494                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19495                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19496                 }
19497                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19498                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19499                 }
19500         }
19501         return NDR_ERR_SUCCESS;
19502 }
19503
19504 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19505 {
19506         uint32_t cntr_info_0;
19507         TALLOC_CTX *_mem_save_info_0;
19508         if (flags & NDR_IN) {
19509                 ZERO_STRUCT(r->out);
19510
19511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19512                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19513         }
19514         if (flags & NDR_OUT) {
19515                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19516                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19517                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19518                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19519                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19520                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19521                 }
19522                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19523                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19524                 }
19525                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19526         }
19527         return NDR_ERR_SUCCESS;
19528 }
19529
19530 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19531 {
19532         uint32_t cntr_info_2;
19533         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19534         ndr->depth++;
19535         if (flags & NDR_SET_VALUES) {
19536                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19537         }
19538         if (flags & NDR_IN) {
19539                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19540                 ndr->depth++;
19541                 ndr_print_ptr(ndr, "handle", r->in.handle);
19542                 ndr->depth++;
19543                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19544                 ndr->depth--;
19545                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19546                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19547                 ndr_print_uint32(ndr, "level", r->in.level);
19548                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19549                 ndr->depth++;
19550                 if (r->in.buffer) {
19551                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19552                 }
19553                 ndr->depth--;
19554                 ndr_print_uint32(ndr, "offered", r->in.offered);
19555                 ndr->depth--;
19556         }
19557         if (flags & NDR_OUT) {
19558                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19559                 ndr->depth++;
19560                 ndr_print_ptr(ndr, "count", r->out.count);
19561                 ndr->depth++;
19562                 ndr_print_uint32(ndr, "count", *r->out.count);
19563                 ndr->depth--;
19564                 ndr_print_ptr(ndr, "info", r->out.info);
19565                 ndr->depth++;
19566                 ndr_print_ptr(ndr, "info", *r->out.info);
19567                 ndr->depth++;
19568                 if (*r->out.info) {
19569                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19570                         ndr->depth++;
19571                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19572                                 char *idx_2=NULL;
19573                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19574                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19575                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19576                                         free(idx_2);
19577                                 }
19578                         }
19579                         ndr->depth--;
19580                 }
19581                 ndr->depth--;
19582                 ndr->depth--;
19583                 ndr_print_ptr(ndr, "needed", r->out.needed);
19584                 ndr->depth++;
19585                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19586                 ndr->depth--;
19587                 ndr_print_WERROR(ndr, "result", r->out.result);
19588                 ndr->depth--;
19589         }
19590         ndr->depth--;
19591 }
19592
19593 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19594 {
19595         if (flags & NDR_IN) {
19596         }
19597         if (flags & NDR_OUT) {
19598                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19599         }
19600         return NDR_ERR_SUCCESS;
19601 }
19602
19603 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19604 {
19605         if (flags & NDR_IN) {
19606         }
19607         if (flags & NDR_OUT) {
19608                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19609         }
19610         return NDR_ERR_SUCCESS;
19611 }
19612
19613 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19614 {
19615         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19616         ndr->depth++;
19617         if (flags & NDR_SET_VALUES) {
19618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19619         }
19620         if (flags & NDR_IN) {
19621                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19622                 ndr->depth++;
19623                 ndr->depth--;
19624         }
19625         if (flags & NDR_OUT) {
19626                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19627                 ndr->depth++;
19628                 ndr_print_WERROR(ndr, "result", r->out.result);
19629                 ndr->depth--;
19630         }
19631         ndr->depth--;
19632 }
19633
19634 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19635 {
19636         if (flags & NDR_IN) {
19637                 if (r->in.handle == NULL) {
19638                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19639                 }
19640                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19641         }
19642         if (flags & NDR_OUT) {
19643                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19644         }
19645         return NDR_ERR_SUCCESS;
19646 }
19647
19648 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19649 {
19650         TALLOC_CTX *_mem_save_handle_0;
19651         if (flags & NDR_IN) {
19652                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19653                         NDR_PULL_ALLOC(ndr, r->in.handle);
19654                 }
19655                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19656                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19657                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19658                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19659         }
19660         if (flags & NDR_OUT) {
19661                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19662         }
19663         return NDR_ERR_SUCCESS;
19664 }
19665
19666 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19667 {
19668         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19669         ndr->depth++;
19670         if (flags & NDR_SET_VALUES) {
19671                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19672         }
19673         if (flags & NDR_IN) {
19674                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19675                 ndr->depth++;
19676                 ndr_print_ptr(ndr, "handle", r->in.handle);
19677                 ndr->depth++;
19678                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19679                 ndr->depth--;
19680                 ndr->depth--;
19681         }
19682         if (flags & NDR_OUT) {
19683                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19684                 ndr->depth++;
19685                 ndr_print_WERROR(ndr, "result", r->out.result);
19686                 ndr->depth--;
19687         }
19688         ndr->depth--;
19689 }
19690
19691 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19692 {
19693         if (flags & NDR_IN) {
19694                 if (r->in.handle == NULL) {
19695                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19696                 }
19697                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19698                 if (r->in.info_ctr == NULL) {
19699                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19700                 }
19701                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19702                 if (r->in.devmode_ctr == NULL) {
19703                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19704                 }
19705                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19706                 if (r->in.secdesc_ctr == NULL) {
19707                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19708                 }
19709                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19710                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19711         }
19712         if (flags & NDR_OUT) {
19713                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19714         }
19715         return NDR_ERR_SUCCESS;
19716 }
19717
19718 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19719 {
19720         TALLOC_CTX *_mem_save_handle_0;
19721         TALLOC_CTX *_mem_save_info_ctr_0;
19722         TALLOC_CTX *_mem_save_devmode_ctr_0;
19723         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19724         if (flags & NDR_IN) {
19725                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19726                         NDR_PULL_ALLOC(ndr, r->in.handle);
19727                 }
19728                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19729                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19730                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19731                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19732                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19733                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19734                 }
19735                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19736                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19737                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19738                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19739                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19740                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19741                 }
19742                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19743                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19744                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19745                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19746                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19747                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19748                 }
19749                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19750                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19751                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19752                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19753                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19754         }
19755         if (flags & NDR_OUT) {
19756                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19757         }
19758         return NDR_ERR_SUCCESS;
19759 }
19760
19761 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19762 {
19763         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19764         ndr->depth++;
19765         if (flags & NDR_SET_VALUES) {
19766                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19767         }
19768         if (flags & NDR_IN) {
19769                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19770                 ndr->depth++;
19771                 ndr_print_ptr(ndr, "handle", r->in.handle);
19772                 ndr->depth++;
19773                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19774                 ndr->depth--;
19775                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19776                 ndr->depth++;
19777                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19778                 ndr->depth--;
19779                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19780                 ndr->depth++;
19781                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19782                 ndr->depth--;
19783                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19784                 ndr->depth++;
19785                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19786                 ndr->depth--;
19787                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19788                 ndr->depth--;
19789         }
19790         if (flags & NDR_OUT) {
19791                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19792                 ndr->depth++;
19793                 ndr_print_WERROR(ndr, "result", r->out.result);
19794                 ndr->depth--;
19795         }
19796         ndr->depth--;
19797 }
19798
19799 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19800 {
19801         if (flags & NDR_IN) {
19802                 if (r->in.handle == NULL) {
19803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19804                 }
19805                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19806                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19807                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19808                 if (r->in.buffer) {
19809                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19810                 }
19811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19812         }
19813         if (flags & NDR_OUT) {
19814                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19815                 if (r->out.info) {
19816                         {
19817                                 struct ndr_push *_ndr_info;
19818                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19819                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19820                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19821                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19822                         }
19823                 }
19824                 if (r->out.needed == NULL) {
19825                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19826                 }
19827                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19828                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19829         }
19830         return NDR_ERR_SUCCESS;
19831 }
19832
19833 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19834 {
19835         uint32_t _ptr_buffer;
19836         uint32_t _ptr_info;
19837         TALLOC_CTX *_mem_save_handle_0;
19838         TALLOC_CTX *_mem_save_buffer_0;
19839         TALLOC_CTX *_mem_save_info_0;
19840         TALLOC_CTX *_mem_save_needed_0;
19841         if (flags & NDR_IN) {
19842                 ZERO_STRUCT(r->out);
19843
19844                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19845                         NDR_PULL_ALLOC(ndr, r->in.handle);
19846                 }
19847                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19848                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19849                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19850                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19851                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19852                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19853                 if (_ptr_buffer) {
19854                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19855                 } else {
19856                         r->in.buffer = NULL;
19857                 }
19858                 if (r->in.buffer) {
19859                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19860                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19861                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19862                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19863                 }
19864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19865                 NDR_PULL_ALLOC(ndr, r->out.needed);
19866                 ZERO_STRUCTP(r->out.needed);
19867         }
19868         if (flags & NDR_OUT) {
19869                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19870                 if (_ptr_info) {
19871                         NDR_PULL_ALLOC(ndr, r->out.info);
19872                 } else {
19873                         r->out.info = NULL;
19874                 }
19875                 if (r->out.info) {
19876                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19877                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19878                         {
19879                                 struct ndr_pull *_ndr_info;
19880                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19881                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19882                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19883                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19884                         }
19885                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19886                 }
19887                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19888                         NDR_PULL_ALLOC(ndr, r->out.needed);
19889                 }
19890                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19891                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19892                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19893                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19894                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19895         }
19896         return NDR_ERR_SUCCESS;
19897 }
19898
19899 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19900 {
19901         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19902         ndr->depth++;
19903         if (flags & NDR_SET_VALUES) {
19904                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19905         }
19906         if (flags & NDR_IN) {
19907                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19908                 ndr->depth++;
19909                 ndr_print_ptr(ndr, "handle", r->in.handle);
19910                 ndr->depth++;
19911                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19912                 ndr->depth--;
19913                 ndr_print_uint32(ndr, "level", r->in.level);
19914                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19915                 ndr->depth++;
19916                 if (r->in.buffer) {
19917                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19918                 }
19919                 ndr->depth--;
19920                 ndr_print_uint32(ndr, "offered", r->in.offered);
19921                 ndr->depth--;
19922         }
19923         if (flags & NDR_OUT) {
19924                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19925                 ndr->depth++;
19926                 ndr_print_ptr(ndr, "info", r->out.info);
19927                 ndr->depth++;
19928                 if (r->out.info) {
19929                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19930                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19931                 }
19932                 ndr->depth--;
19933                 ndr_print_ptr(ndr, "needed", r->out.needed);
19934                 ndr->depth++;
19935                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19936                 ndr->depth--;
19937                 ndr_print_WERROR(ndr, "result", r->out.result);
19938                 ndr->depth--;
19939         }
19940         ndr->depth--;
19941 }
19942
19943 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19944 {
19945         if (flags & NDR_IN) {
19946                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19947                 if (r->in.servername) {
19948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19950                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19951                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19952                 }
19953                 if (r->in.info_ctr == NULL) {
19954                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19955                 }
19956                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19957         }
19958         if (flags & NDR_OUT) {
19959                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19960         }
19961         return NDR_ERR_SUCCESS;
19962 }
19963
19964 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19965 {
19966         uint32_t _ptr_servername;
19967         TALLOC_CTX *_mem_save_servername_0;
19968         TALLOC_CTX *_mem_save_info_ctr_0;
19969         if (flags & NDR_IN) {
19970                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19971                 if (_ptr_servername) {
19972                         NDR_PULL_ALLOC(ndr, r->in.servername);
19973                 } else {
19974                         r->in.servername = NULL;
19975                 }
19976                 if (r->in.servername) {
19977                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19978                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19979                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19980                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19981                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19982                                 return 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));
19983                         }
19984                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19985                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19986                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19987                 }
19988                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19989                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19990                 }
19991                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19992                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19993                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19994                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19995         }
19996         if (flags & NDR_OUT) {
19997                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19998         }
19999         return NDR_ERR_SUCCESS;
20000 }
20001
20002 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
20003 {
20004         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
20005         ndr->depth++;
20006         if (flags & NDR_SET_VALUES) {
20007                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20008         }
20009         if (flags & NDR_IN) {
20010                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
20011                 ndr->depth++;
20012                 ndr_print_ptr(ndr, "servername", r->in.servername);
20013                 ndr->depth++;
20014                 if (r->in.servername) {
20015                         ndr_print_string(ndr, "servername", r->in.servername);
20016                 }
20017                 ndr->depth--;
20018                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
20019                 ndr->depth++;
20020                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
20021                 ndr->depth--;
20022                 ndr->depth--;
20023         }
20024         if (flags & NDR_OUT) {
20025                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
20026                 ndr->depth++;
20027                 ndr_print_WERROR(ndr, "result", r->out.result);
20028                 ndr->depth--;
20029         }
20030         ndr->depth--;
20031 }
20032
20033 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
20034 {
20035         if (flags & NDR_IN) {
20036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20037                 if (r->in.server) {
20038                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20039                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20040                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20041                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20042                 }
20043                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20044                 if (r->in.environment) {
20045                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20048                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20049                 }
20050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20051                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20052                 if (r->in.buffer) {
20053                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20054                 }
20055                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20056         }
20057         if (flags & NDR_OUT) {
20058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20059                 if (r->out.info) {
20060                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20061                 }
20062                 if (r->out.needed == NULL) {
20063                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20064                 }
20065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20066                 if (r->out.count == NULL) {
20067                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20068                 }
20069                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20070                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20071         }
20072         return NDR_ERR_SUCCESS;
20073 }
20074
20075 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
20076 {
20077         uint32_t _ptr_server;
20078         uint32_t _ptr_environment;
20079         uint32_t _ptr_buffer;
20080         uint32_t _ptr_info;
20081         TALLOC_CTX *_mem_save_server_0;
20082         TALLOC_CTX *_mem_save_environment_0;
20083         TALLOC_CTX *_mem_save_buffer_0;
20084         TALLOC_CTX *_mem_save_info_0;
20085         TALLOC_CTX *_mem_save_needed_0;
20086         TALLOC_CTX *_mem_save_count_0;
20087         if (flags & NDR_IN) {
20088                 ZERO_STRUCT(r->out);
20089
20090                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20091                 if (_ptr_server) {
20092                         NDR_PULL_ALLOC(ndr, r->in.server);
20093                 } else {
20094                         r->in.server = NULL;
20095                 }
20096                 if (r->in.server) {
20097                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20098                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20099                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20100                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20101                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20102                                 return 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));
20103                         }
20104                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20105                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20106                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20107                 }
20108                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20109                 if (_ptr_environment) {
20110                         NDR_PULL_ALLOC(ndr, r->in.environment);
20111                 } else {
20112                         r->in.environment = NULL;
20113                 }
20114                 if (r->in.environment) {
20115                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20116                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20117                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20118                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20119                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20120                                 return 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));
20121                         }
20122                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20123                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20124                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20125                 }
20126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20128                 if (_ptr_buffer) {
20129                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20130                 } else {
20131                         r->in.buffer = NULL;
20132                 }
20133                 if (r->in.buffer) {
20134                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20135                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20136                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20137                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20138                 }
20139                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20140                 NDR_PULL_ALLOC(ndr, r->out.needed);
20141                 ZERO_STRUCTP(r->out.needed);
20142                 NDR_PULL_ALLOC(ndr, r->out.count);
20143                 ZERO_STRUCTP(r->out.count);
20144         }
20145         if (flags & NDR_OUT) {
20146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20147                 if (_ptr_info) {
20148                         NDR_PULL_ALLOC(ndr, r->out.info);
20149                 } else {
20150                         r->out.info = NULL;
20151                 }
20152                 if (r->out.info) {
20153                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20154                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20155                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20156                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20157                 }
20158                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20159                         NDR_PULL_ALLOC(ndr, r->out.needed);
20160                 }
20161                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20162                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20163                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20164                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20165                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20166                         NDR_PULL_ALLOC(ndr, r->out.count);
20167                 }
20168                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20169                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20170                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20171                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20172                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20173         }
20174         return NDR_ERR_SUCCESS;
20175 }
20176
20177 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
20178 {
20179         uint32_t cntr_info_0;
20180         if (flags & NDR_IN) {
20181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20183         }
20184         if (flags & NDR_OUT) {
20185                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20186                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20187                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20188                 }
20189                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20190                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20191                 }
20192         }
20193         return NDR_ERR_SUCCESS;
20194 }
20195
20196 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
20197 {
20198         uint32_t cntr_info_0;
20199         TALLOC_CTX *_mem_save_info_0;
20200         if (flags & NDR_IN) {
20201                 ZERO_STRUCT(r->out);
20202
20203                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20204                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20205         }
20206         if (flags & NDR_OUT) {
20207                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20208                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20209                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20210                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20211                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20212                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20213                 }
20214                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20215                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20216                 }
20217                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20218         }
20219         return NDR_ERR_SUCCESS;
20220 }
20221
20222 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
20223 {
20224         uint32_t cntr_info_2;
20225         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
20226         ndr->depth++;
20227         if (flags & NDR_SET_VALUES) {
20228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20229         }
20230         if (flags & NDR_IN) {
20231                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
20232                 ndr->depth++;
20233                 ndr_print_ptr(ndr, "server", r->in.server);
20234                 ndr->depth++;
20235                 if (r->in.server) {
20236                         ndr_print_string(ndr, "server", r->in.server);
20237                 }
20238                 ndr->depth--;
20239                 ndr_print_ptr(ndr, "environment", r->in.environment);
20240                 ndr->depth++;
20241                 if (r->in.environment) {
20242                         ndr_print_string(ndr, "environment", r->in.environment);
20243                 }
20244                 ndr->depth--;
20245                 ndr_print_uint32(ndr, "level", r->in.level);
20246                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20247                 ndr->depth++;
20248                 if (r->in.buffer) {
20249                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20250                 }
20251                 ndr->depth--;
20252                 ndr_print_uint32(ndr, "offered", r->in.offered);
20253                 ndr->depth--;
20254         }
20255         if (flags & NDR_OUT) {
20256                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
20257                 ndr->depth++;
20258                 ndr_print_ptr(ndr, "count", r->out.count);
20259                 ndr->depth++;
20260                 ndr_print_uint32(ndr, "count", *r->out.count);
20261                 ndr->depth--;
20262                 ndr_print_ptr(ndr, "info", r->out.info);
20263                 ndr->depth++;
20264                 ndr_print_ptr(ndr, "info", *r->out.info);
20265                 ndr->depth++;
20266                 if (*r->out.info) {
20267                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20268                         ndr->depth++;
20269                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20270                                 char *idx_2=NULL;
20271                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20272                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20273                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20274                                         free(idx_2);
20275                                 }
20276                         }
20277                         ndr->depth--;
20278                 }
20279                 ndr->depth--;
20280                 ndr->depth--;
20281                 ndr_print_ptr(ndr, "needed", r->out.needed);
20282                 ndr->depth++;
20283                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20284                 ndr->depth--;
20285                 ndr_print_WERROR(ndr, "result", r->out.result);
20286                 ndr->depth--;
20287         }
20288         ndr->depth--;
20289 }
20290
20291 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20292 {
20293         if (flags & NDR_IN) {
20294         }
20295         if (flags & NDR_OUT) {
20296                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20297         }
20298         return NDR_ERR_SUCCESS;
20299 }
20300
20301 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20302 {
20303         if (flags & NDR_IN) {
20304         }
20305         if (flags & NDR_OUT) {
20306                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20307         }
20308         return NDR_ERR_SUCCESS;
20309 }
20310
20311 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20312 {
20313         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
20314         ndr->depth++;
20315         if (flags & NDR_SET_VALUES) {
20316                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20317         }
20318         if (flags & NDR_IN) {
20319                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20320                 ndr->depth++;
20321                 ndr->depth--;
20322         }
20323         if (flags & NDR_OUT) {
20324                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20325                 ndr->depth++;
20326                 ndr_print_WERROR(ndr, "result", r->out.result);
20327                 ndr->depth--;
20328         }
20329         ndr->depth--;
20330 }
20331
20332 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20333 {
20334         if (flags & NDR_IN) {
20335                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20336                 if (r->in.server) {
20337                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20340                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20341                 }
20342                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20343                 if (r->in.environment) {
20344                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20345                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20346                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20347                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20348                 }
20349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20350                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20351                 if (r->in.buffer) {
20352                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20353                 }
20354                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20355         }
20356         if (flags & NDR_OUT) {
20357                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20358                 if (r->out.info) {
20359                         {
20360                                 struct ndr_push *_ndr_info;
20361                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20362                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20363                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20364                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20365                         }
20366                 }
20367                 if (r->out.needed == NULL) {
20368                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20369                 }
20370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20371                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20372         }
20373         return NDR_ERR_SUCCESS;
20374 }
20375
20376 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20377 {
20378         uint32_t _ptr_server;
20379         uint32_t _ptr_environment;
20380         uint32_t _ptr_buffer;
20381         uint32_t _ptr_info;
20382         TALLOC_CTX *_mem_save_server_0;
20383         TALLOC_CTX *_mem_save_environment_0;
20384         TALLOC_CTX *_mem_save_buffer_0;
20385         TALLOC_CTX *_mem_save_info_0;
20386         TALLOC_CTX *_mem_save_needed_0;
20387         if (flags & NDR_IN) {
20388                 ZERO_STRUCT(r->out);
20389
20390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20391                 if (_ptr_server) {
20392                         NDR_PULL_ALLOC(ndr, r->in.server);
20393                 } else {
20394                         r->in.server = NULL;
20395                 }
20396                 if (r->in.server) {
20397                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20398                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20399                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20400                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20401                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20402                                 return 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));
20403                         }
20404                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20405                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20406                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20407                 }
20408                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20409                 if (_ptr_environment) {
20410                         NDR_PULL_ALLOC(ndr, r->in.environment);
20411                 } else {
20412                         r->in.environment = NULL;
20413                 }
20414                 if (r->in.environment) {
20415                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20416                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20417                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20418                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20419                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20420                                 return 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));
20421                         }
20422                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20423                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20424                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20425                 }
20426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20427                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20428                 if (_ptr_buffer) {
20429                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20430                 } else {
20431                         r->in.buffer = NULL;
20432                 }
20433                 if (r->in.buffer) {
20434                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20435                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20436                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20437                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20438                 }
20439                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20440                 NDR_PULL_ALLOC(ndr, r->out.needed);
20441                 ZERO_STRUCTP(r->out.needed);
20442         }
20443         if (flags & NDR_OUT) {
20444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20445                 if (_ptr_info) {
20446                         NDR_PULL_ALLOC(ndr, r->out.info);
20447                 } else {
20448                         r->out.info = NULL;
20449                 }
20450                 if (r->out.info) {
20451                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20452                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20453                         {
20454                                 struct ndr_pull *_ndr_info;
20455                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20456                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20457                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20458                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20459                         }
20460                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20461                 }
20462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20463                         NDR_PULL_ALLOC(ndr, r->out.needed);
20464                 }
20465                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20466                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20467                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20469                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20470         }
20471         return NDR_ERR_SUCCESS;
20472 }
20473
20474 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20475 {
20476         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20477         ndr->depth++;
20478         if (flags & NDR_SET_VALUES) {
20479                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20480         }
20481         if (flags & NDR_IN) {
20482                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20483                 ndr->depth++;
20484                 ndr_print_ptr(ndr, "server", r->in.server);
20485                 ndr->depth++;
20486                 if (r->in.server) {
20487                         ndr_print_string(ndr, "server", r->in.server);
20488                 }
20489                 ndr->depth--;
20490                 ndr_print_ptr(ndr, "environment", r->in.environment);
20491                 ndr->depth++;
20492                 if (r->in.environment) {
20493                         ndr_print_string(ndr, "environment", r->in.environment);
20494                 }
20495                 ndr->depth--;
20496                 ndr_print_uint32(ndr, "level", r->in.level);
20497                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20498                 ndr->depth++;
20499                 if (r->in.buffer) {
20500                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20501                 }
20502                 ndr->depth--;
20503                 ndr_print_uint32(ndr, "offered", r->in.offered);
20504                 ndr->depth--;
20505         }
20506         if (flags & NDR_OUT) {
20507                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20508                 ndr->depth++;
20509                 ndr_print_ptr(ndr, "info", r->out.info);
20510                 ndr->depth++;
20511                 if (r->out.info) {
20512                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20513                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20514                 }
20515                 ndr->depth--;
20516                 ndr_print_ptr(ndr, "needed", r->out.needed);
20517                 ndr->depth++;
20518                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20519                 ndr->depth--;
20520                 ndr_print_WERROR(ndr, "result", r->out.result);
20521                 ndr->depth--;
20522         }
20523         ndr->depth--;
20524 }
20525
20526 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20527 {
20528         if (flags & NDR_IN) {
20529                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20530                 if (r->in.server) {
20531                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20532                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20533                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20534                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20535                 }
20536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20537                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20538                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20539                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20540                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20541                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20542                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20543                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20544         }
20545         if (flags & NDR_OUT) {
20546                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20547         }
20548         return NDR_ERR_SUCCESS;
20549 }
20550
20551 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20552 {
20553         uint32_t _ptr_server;
20554         TALLOC_CTX *_mem_save_server_0;
20555         if (flags & NDR_IN) {
20556                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20557                 if (_ptr_server) {
20558                         NDR_PULL_ALLOC(ndr, r->in.server);
20559                 } else {
20560                         r->in.server = NULL;
20561                 }
20562                 if (r->in.server) {
20563                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20564                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20565                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20566                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20567                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20568                                 return 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));
20569                         }
20570                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20571                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20573                 }
20574                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20575                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20576                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20577                         return 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));
20578                 }
20579                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20580                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20581                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20582                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20583                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20584                         return 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));
20585                 }
20586                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20587                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20588         }
20589         if (flags & NDR_OUT) {
20590                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20591         }
20592         return NDR_ERR_SUCCESS;
20593 }
20594
20595 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20596 {
20597         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20598         ndr->depth++;
20599         if (flags & NDR_SET_VALUES) {
20600                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20601         }
20602         if (flags & NDR_IN) {
20603                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20604                 ndr->depth++;
20605                 ndr_print_ptr(ndr, "server", r->in.server);
20606                 ndr->depth++;
20607                 if (r->in.server) {
20608                         ndr_print_string(ndr, "server", r->in.server);
20609                 }
20610                 ndr->depth--;
20611                 ndr_print_string(ndr, "architecture", r->in.architecture);
20612                 ndr_print_string(ndr, "driver", r->in.driver);
20613                 ndr->depth--;
20614         }
20615         if (flags & NDR_OUT) {
20616                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20617                 ndr->depth++;
20618                 ndr_print_WERROR(ndr, "result", r->out.result);
20619                 ndr->depth--;
20620         }
20621         ndr->depth--;
20622 }
20623
20624 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20625 {
20626         if (flags & NDR_IN) {
20627                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20628                 if (r->in.server) {
20629                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20631                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20632                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20633                 }
20634                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20637                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20641                 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));
20642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, 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.print_processor_name, CH_UTF16)));
20645                 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));
20646         }
20647         if (flags & NDR_OUT) {
20648                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20649         }
20650         return NDR_ERR_SUCCESS;
20651 }
20652
20653 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20654 {
20655         uint32_t _ptr_server;
20656         TALLOC_CTX *_mem_save_server_0;
20657         if (flags & NDR_IN) {
20658                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20659                 if (_ptr_server) {
20660                         NDR_PULL_ALLOC(ndr, r->in.server);
20661                 } else {
20662                         r->in.server = NULL;
20663                 }
20664                 if (r->in.server) {
20665                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20666                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20667                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20668                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20669                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20670                                 return 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));
20671                         }
20672                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20673                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20674                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20675                 }
20676                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20677                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20678                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20679                         return 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));
20680                 }
20681                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20682                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20683                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20684                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20685                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20686                         return 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));
20687                 }
20688                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20689                 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));
20690                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20691                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20692                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20693                         return 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));
20694                 }
20695                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20696                 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));
20697         }
20698         if (flags & NDR_OUT) {
20699                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20700         }
20701         return NDR_ERR_SUCCESS;
20702 }
20703
20704 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20705 {
20706         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20707         ndr->depth++;
20708         if (flags & NDR_SET_VALUES) {
20709                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20710         }
20711         if (flags & NDR_IN) {
20712                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20713                 ndr->depth++;
20714                 ndr_print_ptr(ndr, "server", r->in.server);
20715                 ndr->depth++;
20716                 if (r->in.server) {
20717                         ndr_print_string(ndr, "server", r->in.server);
20718                 }
20719                 ndr->depth--;
20720                 ndr_print_string(ndr, "architecture", r->in.architecture);
20721                 ndr_print_string(ndr, "path_name", r->in.path_name);
20722                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20723                 ndr->depth--;
20724         }
20725         if (flags & NDR_OUT) {
20726                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20727                 ndr->depth++;
20728                 ndr_print_WERROR(ndr, "result", r->out.result);
20729                 ndr->depth--;
20730         }
20731         ndr->depth--;
20732 }
20733
20734 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20735 {
20736         if (flags & NDR_IN) {
20737                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20738                 if (r->in.servername) {
20739                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20740                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20741                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20742                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20743                 }
20744                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20745                 if (r->in.environment) {
20746                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20749                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20750                 }
20751                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20753                 if (r->in.buffer) {
20754                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20755                 }
20756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20757         }
20758         if (flags & NDR_OUT) {
20759                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20760                 if (r->out.info) {
20761                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20762                 }
20763                 if (r->out.needed == NULL) {
20764                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20765                 }
20766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20767                 if (r->out.count == NULL) {
20768                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20769                 }
20770                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20771                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20772         }
20773         return NDR_ERR_SUCCESS;
20774 }
20775
20776 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20777 {
20778         uint32_t _ptr_servername;
20779         uint32_t _ptr_environment;
20780         uint32_t _ptr_buffer;
20781         uint32_t _ptr_info;
20782         TALLOC_CTX *_mem_save_servername_0;
20783         TALLOC_CTX *_mem_save_environment_0;
20784         TALLOC_CTX *_mem_save_buffer_0;
20785         TALLOC_CTX *_mem_save_info_0;
20786         TALLOC_CTX *_mem_save_needed_0;
20787         TALLOC_CTX *_mem_save_count_0;
20788         if (flags & NDR_IN) {
20789                 ZERO_STRUCT(r->out);
20790
20791                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20792                 if (_ptr_servername) {
20793                         NDR_PULL_ALLOC(ndr, r->in.servername);
20794                 } else {
20795                         r->in.servername = NULL;
20796                 }
20797                 if (r->in.servername) {
20798                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20799                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20800                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20801                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20802                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20803                                 return 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));
20804                         }
20805                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20806                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20807                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20808                 }
20809                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20810                 if (_ptr_environment) {
20811                         NDR_PULL_ALLOC(ndr, r->in.environment);
20812                 } else {
20813                         r->in.environment = NULL;
20814                 }
20815                 if (r->in.environment) {
20816                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20817                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20818                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20819                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20820                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20821                                 return 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));
20822                         }
20823                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20824                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20825                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20826                 }
20827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20828                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20829                 if (_ptr_buffer) {
20830                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20831                 } else {
20832                         r->in.buffer = NULL;
20833                 }
20834                 if (r->in.buffer) {
20835                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20836                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20837                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20838                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20839                 }
20840                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20841                 NDR_PULL_ALLOC(ndr, r->out.needed);
20842                 ZERO_STRUCTP(r->out.needed);
20843                 NDR_PULL_ALLOC(ndr, r->out.count);
20844                 ZERO_STRUCTP(r->out.count);
20845         }
20846         if (flags & NDR_OUT) {
20847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20848                 if (_ptr_info) {
20849                         NDR_PULL_ALLOC(ndr, r->out.info);
20850                 } else {
20851                         r->out.info = NULL;
20852                 }
20853                 if (r->out.info) {
20854                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20855                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20856                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20857                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20858                 }
20859                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20860                         NDR_PULL_ALLOC(ndr, r->out.needed);
20861                 }
20862                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20863                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20864                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20865                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20866                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20867                         NDR_PULL_ALLOC(ndr, r->out.count);
20868                 }
20869                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20870                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20871                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20872                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20873                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20874         }
20875         return NDR_ERR_SUCCESS;
20876 }
20877
20878 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20879 {
20880         uint32_t cntr_info_0;
20881         if (flags & NDR_IN) {
20882                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20884         }
20885         if (flags & NDR_OUT) {
20886                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20887                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20888                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20889                 }
20890                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20891                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20892                 }
20893         }
20894         return NDR_ERR_SUCCESS;
20895 }
20896
20897 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20898 {
20899         uint32_t cntr_info_0;
20900         TALLOC_CTX *_mem_save_info_0;
20901         if (flags & NDR_IN) {
20902                 ZERO_STRUCT(r->out);
20903
20904                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20905                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20906         }
20907         if (flags & NDR_OUT) {
20908                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20909                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20910                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20911                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20912                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20913                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20914                 }
20915                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20916                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20917                 }
20918                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20919         }
20920         return NDR_ERR_SUCCESS;
20921 }
20922
20923 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20924 {
20925         uint32_t cntr_info_2;
20926         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20927         ndr->depth++;
20928         if (flags & NDR_SET_VALUES) {
20929                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20930         }
20931         if (flags & NDR_IN) {
20932                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20933                 ndr->depth++;
20934                 ndr_print_ptr(ndr, "servername", r->in.servername);
20935                 ndr->depth++;
20936                 if (r->in.servername) {
20937                         ndr_print_string(ndr, "servername", r->in.servername);
20938                 }
20939                 ndr->depth--;
20940                 ndr_print_ptr(ndr, "environment", r->in.environment);
20941                 ndr->depth++;
20942                 if (r->in.environment) {
20943                         ndr_print_string(ndr, "environment", r->in.environment);
20944                 }
20945                 ndr->depth--;
20946                 ndr_print_uint32(ndr, "level", r->in.level);
20947                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20948                 ndr->depth++;
20949                 if (r->in.buffer) {
20950                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20951                 }
20952                 ndr->depth--;
20953                 ndr_print_uint32(ndr, "offered", r->in.offered);
20954                 ndr->depth--;
20955         }
20956         if (flags & NDR_OUT) {
20957                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20958                 ndr->depth++;
20959                 ndr_print_ptr(ndr, "count", r->out.count);
20960                 ndr->depth++;
20961                 ndr_print_uint32(ndr, "count", *r->out.count);
20962                 ndr->depth--;
20963                 ndr_print_ptr(ndr, "info", r->out.info);
20964                 ndr->depth++;
20965                 ndr_print_ptr(ndr, "info", *r->out.info);
20966                 ndr->depth++;
20967                 if (*r->out.info) {
20968                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20969                         ndr->depth++;
20970                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20971                                 char *idx_2=NULL;
20972                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20973                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20974                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20975                                         free(idx_2);
20976                                 }
20977                         }
20978                         ndr->depth--;
20979                 }
20980                 ndr->depth--;
20981                 ndr->depth--;
20982                 ndr_print_ptr(ndr, "needed", r->out.needed);
20983                 ndr->depth++;
20984                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20985                 ndr->depth--;
20986                 ndr_print_WERROR(ndr, "result", r->out.result);
20987                 ndr->depth--;
20988         }
20989         ndr->depth--;
20990 }
20991
20992 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20993 {
20994         if (flags & NDR_IN) {
20995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20996                 if (r->in.server) {
20997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
21000                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21001                 }
21002                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
21003                 if (r->in.environment) {
21004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21005                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21006                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
21007                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
21008                 }
21009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21010                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21011                 if (r->in.buffer) {
21012                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
21013                 }
21014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21015         }
21016         if (flags & NDR_OUT) {
21017                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
21018                 if (r->out.info) {
21019                         {
21020                                 struct ndr_push *_ndr_info;
21021                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21022                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21023                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21024                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21025                         }
21026                 }
21027                 if (r->out.needed == NULL) {
21028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21029                 }
21030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21032         }
21033         return NDR_ERR_SUCCESS;
21034 }
21035
21036 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
21037 {
21038         uint32_t _ptr_server;
21039         uint32_t _ptr_environment;
21040         uint32_t _ptr_buffer;
21041         uint32_t _ptr_info;
21042         TALLOC_CTX *_mem_save_server_0;
21043         TALLOC_CTX *_mem_save_environment_0;
21044         TALLOC_CTX *_mem_save_buffer_0;
21045         TALLOC_CTX *_mem_save_info_0;
21046         TALLOC_CTX *_mem_save_needed_0;
21047         if (flags & NDR_IN) {
21048                 ZERO_STRUCT(r->out);
21049
21050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21051                 if (_ptr_server) {
21052                         NDR_PULL_ALLOC(ndr, r->in.server);
21053                 } else {
21054                         r->in.server = NULL;
21055                 }
21056                 if (r->in.server) {
21057                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21058                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21059                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21060                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21061                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21062                                 return 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));
21063                         }
21064                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21065                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21066                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21067                 }
21068                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21069                 if (_ptr_environment) {
21070                         NDR_PULL_ALLOC(ndr, r->in.environment);
21071                 } else {
21072                         r->in.environment = NULL;
21073                 }
21074                 if (r->in.environment) {
21075                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21076                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21077                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21078                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21079                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21080                                 return 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));
21081                         }
21082                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21083                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21084                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21085                 }
21086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21087                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21088                 if (_ptr_buffer) {
21089                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21090                 } else {
21091                         r->in.buffer = NULL;
21092                 }
21093                 if (r->in.buffer) {
21094                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21095                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21096                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21097                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21098                 }
21099                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21100                 NDR_PULL_ALLOC(ndr, r->out.needed);
21101                 ZERO_STRUCTP(r->out.needed);
21102         }
21103         if (flags & NDR_OUT) {
21104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21105                 if (_ptr_info) {
21106                         NDR_PULL_ALLOC(ndr, r->out.info);
21107                 } else {
21108                         r->out.info = NULL;
21109                 }
21110                 if (r->out.info) {
21111                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21112                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21113                         {
21114                                 struct ndr_pull *_ndr_info;
21115                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21116                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21117                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21118                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21119                         }
21120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21121                 }
21122                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21123                         NDR_PULL_ALLOC(ndr, r->out.needed);
21124                 }
21125                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21126                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21128                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21129                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21130         }
21131         return NDR_ERR_SUCCESS;
21132 }
21133
21134 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21135 {
21136         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
21137         ndr->depth++;
21138         if (flags & NDR_SET_VALUES) {
21139                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21140         }
21141         if (flags & NDR_IN) {
21142                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
21143                 ndr->depth++;
21144                 ndr_print_ptr(ndr, "server", r->in.server);
21145                 ndr->depth++;
21146                 if (r->in.server) {
21147                         ndr_print_string(ndr, "server", r->in.server);
21148                 }
21149                 ndr->depth--;
21150                 ndr_print_ptr(ndr, "environment", r->in.environment);
21151                 ndr->depth++;
21152                 if (r->in.environment) {
21153                         ndr_print_string(ndr, "environment", r->in.environment);
21154                 }
21155                 ndr->depth--;
21156                 ndr_print_uint32(ndr, "level", r->in.level);
21157                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21158                 ndr->depth++;
21159                 if (r->in.buffer) {
21160                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21161                 }
21162                 ndr->depth--;
21163                 ndr_print_uint32(ndr, "offered", r->in.offered);
21164                 ndr->depth--;
21165         }
21166         if (flags & NDR_OUT) {
21167                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
21168                 ndr->depth++;
21169                 ndr_print_ptr(ndr, "info", r->out.info);
21170                 ndr->depth++;
21171                 if (r->out.info) {
21172                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21173                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
21174                 }
21175                 ndr->depth--;
21176                 ndr_print_ptr(ndr, "needed", r->out.needed);
21177                 ndr->depth++;
21178                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21179                 ndr->depth--;
21180                 ndr_print_WERROR(ndr, "result", r->out.result);
21181                 ndr->depth--;
21182         }
21183         ndr->depth--;
21184 }
21185
21186 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
21187 {
21188         if (flags & NDR_IN) {
21189                 if (r->in.handle == NULL) {
21190                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21191                 }
21192                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21194                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21195                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21196         }
21197         if (flags & NDR_OUT) {
21198                 if (r->out.job_id == NULL) {
21199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21200                 }
21201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
21202                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21203         }
21204         return NDR_ERR_SUCCESS;
21205 }
21206
21207 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
21208 {
21209         TALLOC_CTX *_mem_save_handle_0;
21210         TALLOC_CTX *_mem_save_job_id_0;
21211         if (flags & NDR_IN) {
21212                 ZERO_STRUCT(r->out);
21213
21214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21215                         NDR_PULL_ALLOC(ndr, r->in.handle);
21216                 }
21217                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21218                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21222                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21223                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21224                 NDR_PULL_ALLOC(ndr, r->out.job_id);
21225                 ZERO_STRUCTP(r->out.job_id);
21226         }
21227         if (flags & NDR_OUT) {
21228                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21229                         NDR_PULL_ALLOC(ndr, r->out.job_id);
21230                 }
21231                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
21232                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
21233                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
21234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_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_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
21241 {
21242         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
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_StartDocPrinter");
21249                 ndr->depth++;
21250                 ndr_print_ptr(ndr, "handle", r->in.handle);
21251                 ndr->depth++;
21252                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21253                 ndr->depth--;
21254                 ndr_print_uint32(ndr, "level", r->in.level);
21255                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21256                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
21257                 ndr->depth--;
21258         }
21259         if (flags & NDR_OUT) {
21260                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
21261                 ndr->depth++;
21262                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
21263                 ndr->depth++;
21264                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
21265                 ndr->depth--;
21266                 ndr_print_WERROR(ndr, "result", r->out.result);
21267                 ndr->depth--;
21268         }
21269         ndr->depth--;
21270 }
21271
21272 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
21273 {
21274         if (flags & NDR_IN) {
21275                 if (r->in.handle == NULL) {
21276                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21277                 }
21278                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21279         }
21280         if (flags & NDR_OUT) {
21281                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21282         }
21283         return NDR_ERR_SUCCESS;
21284 }
21285
21286 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
21287 {
21288         TALLOC_CTX *_mem_save_handle_0;
21289         if (flags & NDR_IN) {
21290                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21291                         NDR_PULL_ALLOC(ndr, r->in.handle);
21292                 }
21293                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21294                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21295                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21296                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21297         }
21298         if (flags & NDR_OUT) {
21299                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21300         }
21301         return NDR_ERR_SUCCESS;
21302 }
21303
21304 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
21305 {
21306         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
21307         ndr->depth++;
21308         if (flags & NDR_SET_VALUES) {
21309                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21310         }
21311         if (flags & NDR_IN) {
21312                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
21313                 ndr->depth++;
21314                 ndr_print_ptr(ndr, "handle", r->in.handle);
21315                 ndr->depth++;
21316                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21317                 ndr->depth--;
21318                 ndr->depth--;
21319         }
21320         if (flags & NDR_OUT) {
21321                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21322                 ndr->depth++;
21323                 ndr_print_WERROR(ndr, "result", r->out.result);
21324                 ndr->depth--;
21325         }
21326         ndr->depth--;
21327 }
21328
21329 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21330 {
21331         if (flags & NDR_IN) {
21332                 if (r->in.handle == NULL) {
21333                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21334                 }
21335                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21336                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21338         }
21339         if (flags & NDR_OUT) {
21340                 if (r->out.num_written == NULL) {
21341                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21342                 }
21343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21344                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21345         }
21346         return NDR_ERR_SUCCESS;
21347 }
21348
21349 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21350 {
21351         TALLOC_CTX *_mem_save_handle_0;
21352         TALLOC_CTX *_mem_save_num_written_0;
21353         if (flags & NDR_IN) {
21354                 ZERO_STRUCT(r->out);
21355
21356                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21357                         NDR_PULL_ALLOC(ndr, r->in.handle);
21358                 }
21359                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21360                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21361                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21362                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21363                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21365                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21366                 ZERO_STRUCTP(r->out.num_written);
21367         }
21368         if (flags & NDR_OUT) {
21369                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21370                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21371                 }
21372                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21373                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21374                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21375                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21377         }
21378         return NDR_ERR_SUCCESS;
21379 }
21380
21381 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21382 {
21383         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21384         ndr->depth++;
21385         if (flags & NDR_SET_VALUES) {
21386                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21387         }
21388         if (flags & NDR_IN) {
21389                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21390                 ndr->depth++;
21391                 ndr_print_ptr(ndr, "handle", r->in.handle);
21392                 ndr->depth++;
21393                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21394                 ndr->depth--;
21395                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21396                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21397                 ndr->depth--;
21398         }
21399         if (flags & NDR_OUT) {
21400                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21401                 ndr->depth++;
21402                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21403                 ndr->depth++;
21404                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21405                 ndr->depth--;
21406                 ndr_print_WERROR(ndr, "result", r->out.result);
21407                 ndr->depth--;
21408         }
21409         ndr->depth--;
21410 }
21411
21412 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21413 {
21414         if (flags & NDR_IN) {
21415                 if (r->in.handle == NULL) {
21416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21417                 }
21418                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21419         }
21420         if (flags & NDR_OUT) {
21421                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21422         }
21423         return NDR_ERR_SUCCESS;
21424 }
21425
21426 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21427 {
21428         TALLOC_CTX *_mem_save_handle_0;
21429         if (flags & NDR_IN) {
21430                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21431                         NDR_PULL_ALLOC(ndr, r->in.handle);
21432                 }
21433                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21434                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21435                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21436                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21437         }
21438         if (flags & NDR_OUT) {
21439                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21440         }
21441         return NDR_ERR_SUCCESS;
21442 }
21443
21444 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21445 {
21446         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21447         ndr->depth++;
21448         if (flags & NDR_SET_VALUES) {
21449                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21450         }
21451         if (flags & NDR_IN) {
21452                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21453                 ndr->depth++;
21454                 ndr_print_ptr(ndr, "handle", r->in.handle);
21455                 ndr->depth++;
21456                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21457                 ndr->depth--;
21458                 ndr->depth--;
21459         }
21460         if (flags & NDR_OUT) {
21461                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21462                 ndr->depth++;
21463                 ndr_print_WERROR(ndr, "result", r->out.result);
21464                 ndr->depth--;
21465         }
21466         ndr->depth--;
21467 }
21468
21469 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21470 {
21471         if (flags & NDR_IN) {
21472                 if (r->in.handle == NULL) {
21473                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21474                 }
21475                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21476         }
21477         if (flags & NDR_OUT) {
21478                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21479         }
21480         return NDR_ERR_SUCCESS;
21481 }
21482
21483 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21484 {
21485         TALLOC_CTX *_mem_save_handle_0;
21486         if (flags & NDR_IN) {
21487                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21488                         NDR_PULL_ALLOC(ndr, r->in.handle);
21489                 }
21490                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21491                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21492                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21493                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21494         }
21495         if (flags & NDR_OUT) {
21496                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21497         }
21498         return NDR_ERR_SUCCESS;
21499 }
21500
21501 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21502 {
21503         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21504         ndr->depth++;
21505         if (flags & NDR_SET_VALUES) {
21506                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21507         }
21508         if (flags & NDR_IN) {
21509                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21510                 ndr->depth++;
21511                 ndr_print_ptr(ndr, "handle", r->in.handle);
21512                 ndr->depth++;
21513                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21514                 ndr->depth--;
21515                 ndr->depth--;
21516         }
21517         if (flags & NDR_OUT) {
21518                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21519                 ndr->depth++;
21520                 ndr_print_WERROR(ndr, "result", r->out.result);
21521                 ndr->depth--;
21522         }
21523         ndr->depth--;
21524 }
21525
21526 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21527 {
21528         if (flags & NDR_IN) {
21529                 if (r->in.handle == NULL) {
21530                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21531                 }
21532                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21533                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21534         }
21535         if (flags & NDR_OUT) {
21536                 if (r->out.data == NULL) {
21537                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21538                 }
21539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21540                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21541                 if (r->out._data_size == NULL) {
21542                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21543                 }
21544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21545                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21546         }
21547         return NDR_ERR_SUCCESS;
21548 }
21549
21550 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21551 {
21552         TALLOC_CTX *_mem_save_handle_0;
21553         TALLOC_CTX *_mem_save__data_size_0;
21554         if (flags & NDR_IN) {
21555                 ZERO_STRUCT(r->out);
21556
21557                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21558                         NDR_PULL_ALLOC(ndr, r->in.handle);
21559                 }
21560                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21561                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21562                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21563                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21564                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21565                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21566                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21567                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21568                 ZERO_STRUCTP(r->out._data_size);
21569         }
21570         if (flags & NDR_OUT) {
21571                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21572                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21573                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21574                 }
21575                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21576                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21577                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21578                 }
21579                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21580                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21581                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21582                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21583                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21584                 if (r->out.data) {
21585                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21586                 }
21587         }
21588         return NDR_ERR_SUCCESS;
21589 }
21590
21591 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21592 {
21593         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21594         ndr->depth++;
21595         if (flags & NDR_SET_VALUES) {
21596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21597         }
21598         if (flags & NDR_IN) {
21599                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21600                 ndr->depth++;
21601                 ndr_print_ptr(ndr, "handle", r->in.handle);
21602                 ndr->depth++;
21603                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21604                 ndr->depth--;
21605                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21606                 ndr->depth--;
21607         }
21608         if (flags & NDR_OUT) {
21609                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21610                 ndr->depth++;
21611                 ndr_print_ptr(ndr, "data", r->out.data);
21612                 ndr->depth++;
21613                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21614                 ndr->depth--;
21615                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21616                 ndr->depth++;
21617                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21618                 ndr->depth--;
21619                 ndr_print_WERROR(ndr, "result", r->out.result);
21620                 ndr->depth--;
21621         }
21622         ndr->depth--;
21623 }
21624
21625 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21626 {
21627         if (flags & NDR_IN) {
21628                 if (r->in.handle == NULL) {
21629                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21630                 }
21631                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21632         }
21633         if (flags & NDR_OUT) {
21634                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21635         }
21636         return NDR_ERR_SUCCESS;
21637 }
21638
21639 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21640 {
21641         TALLOC_CTX *_mem_save_handle_0;
21642         if (flags & NDR_IN) {
21643                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21644                         NDR_PULL_ALLOC(ndr, r->in.handle);
21645                 }
21646                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21647                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21648                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21649                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21650         }
21651         if (flags & NDR_OUT) {
21652                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21653         }
21654         return NDR_ERR_SUCCESS;
21655 }
21656
21657 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21658 {
21659         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21660         ndr->depth++;
21661         if (flags & NDR_SET_VALUES) {
21662                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21663         }
21664         if (flags & NDR_IN) {
21665                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21666                 ndr->depth++;
21667                 ndr_print_ptr(ndr, "handle", r->in.handle);
21668                 ndr->depth++;
21669                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21670                 ndr->depth--;
21671                 ndr->depth--;
21672         }
21673         if (flags & NDR_OUT) {
21674                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21675                 ndr->depth++;
21676                 ndr_print_WERROR(ndr, "result", r->out.result);
21677                 ndr->depth--;
21678         }
21679         ndr->depth--;
21680 }
21681
21682 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21683 {
21684         if (flags & NDR_IN) {
21685                 if (r->in.handle == NULL) {
21686                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21687                 }
21688                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21689                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21690                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21691                 if (r->in.buffer) {
21692                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21693                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21694                 }
21695                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21696         }
21697         if (flags & NDR_OUT) {
21698                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21699                 if (r->out.buffer) {
21700                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21701                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21702                 }
21703                 if (r->out.needed == NULL) {
21704                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21705                 }
21706                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21707                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21708         }
21709         return NDR_ERR_SUCCESS;
21710 }
21711
21712 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21713 {
21714         uint32_t _ptr_buffer;
21715         TALLOC_CTX *_mem_save_handle_0;
21716         TALLOC_CTX *_mem_save_buffer_0;
21717         TALLOC_CTX *_mem_save_needed_0;
21718         if (flags & NDR_IN) {
21719                 ZERO_STRUCT(r->out);
21720
21721                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21722                         NDR_PULL_ALLOC(ndr, r->in.handle);
21723                 }
21724                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21725                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21726                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21727                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21728                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21729                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21730                 if (_ptr_buffer) {
21731                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21732                 } else {
21733                         r->in.buffer = NULL;
21734                 }
21735                 if (r->in.buffer) {
21736                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21737                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21738                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21739                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21740                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21742                 }
21743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21744                 NDR_PULL_ALLOC(ndr, r->out.needed);
21745                 ZERO_STRUCTP(r->out.needed);
21746                 if (r->in.buffer) {
21747                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21748                 }
21749         }
21750         if (flags & NDR_OUT) {
21751                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21752                 if (_ptr_buffer) {
21753                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21754                 } else {
21755                         r->out.buffer = NULL;
21756                 }
21757                 if (r->out.buffer) {
21758                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21759                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21760                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21761                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21762                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21763                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21764                 }
21765                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21766                         NDR_PULL_ALLOC(ndr, r->out.needed);
21767                 }
21768                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21769                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21770                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21771                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21772                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21773                 if (r->out.buffer) {
21774                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21775                 }
21776         }
21777         return NDR_ERR_SUCCESS;
21778 }
21779
21780 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21781 {
21782         ndr_print_struct(ndr, name, "spoolss_AddJob");
21783         ndr->depth++;
21784         if (flags & NDR_SET_VALUES) {
21785                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21786         }
21787         if (flags & NDR_IN) {
21788                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21789                 ndr->depth++;
21790                 ndr_print_ptr(ndr, "handle", r->in.handle);
21791                 ndr->depth++;
21792                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21793                 ndr->depth--;
21794                 ndr_print_uint32(ndr, "level", r->in.level);
21795                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21796                 ndr->depth++;
21797                 if (r->in.buffer) {
21798                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21799                 }
21800                 ndr->depth--;
21801                 ndr_print_uint32(ndr, "offered", r->in.offered);
21802                 ndr->depth--;
21803         }
21804         if (flags & NDR_OUT) {
21805                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21806                 ndr->depth++;
21807                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21808                 ndr->depth++;
21809                 if (r->out.buffer) {
21810                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21811                 }
21812                 ndr->depth--;
21813                 ndr_print_ptr(ndr, "needed", r->out.needed);
21814                 ndr->depth++;
21815                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21816                 ndr->depth--;
21817                 ndr_print_WERROR(ndr, "result", r->out.result);
21818                 ndr->depth--;
21819         }
21820         ndr->depth--;
21821 }
21822
21823 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21824 {
21825         if (flags & NDR_IN) {
21826                 if (r->in.handle == NULL) {
21827                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21828                 }
21829                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21830                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21831         }
21832         if (flags & NDR_OUT) {
21833                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21834         }
21835         return NDR_ERR_SUCCESS;
21836 }
21837
21838 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21839 {
21840         TALLOC_CTX *_mem_save_handle_0;
21841         if (flags & NDR_IN) {
21842                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21843                         NDR_PULL_ALLOC(ndr, r->in.handle);
21844                 }
21845                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21846                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21847                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21848                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21850         }
21851         if (flags & NDR_OUT) {
21852                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21853         }
21854         return NDR_ERR_SUCCESS;
21855 }
21856
21857 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21858 {
21859         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21860         ndr->depth++;
21861         if (flags & NDR_SET_VALUES) {
21862                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21863         }
21864         if (flags & NDR_IN) {
21865                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21866                 ndr->depth++;
21867                 ndr_print_ptr(ndr, "handle", r->in.handle);
21868                 ndr->depth++;
21869                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21870                 ndr->depth--;
21871                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21872                 ndr->depth--;
21873         }
21874         if (flags & NDR_OUT) {
21875                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21876                 ndr->depth++;
21877                 ndr_print_WERROR(ndr, "result", r->out.result);
21878                 ndr->depth--;
21879         }
21880         ndr->depth--;
21881 }
21882
21883 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21884 {
21885         if (flags & NDR_IN) {
21886                 if (r->in.handle == NULL) {
21887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21888                 }
21889                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21892                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21893                 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));
21894                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21895         }
21896         if (flags & NDR_OUT) {
21897                 if (r->out.type == NULL) {
21898                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21899                 }
21900                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
21901                 if (r->out.data == NULL) {
21902                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21903                 }
21904                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
21905                 if (r->out.needed == NULL) {
21906                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21907                 }
21908                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21909                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21910         }
21911         return NDR_ERR_SUCCESS;
21912 }
21913
21914 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21915 {
21916         TALLOC_CTX *_mem_save_handle_0;
21917         TALLOC_CTX *_mem_save_type_0;
21918         TALLOC_CTX *_mem_save_data_0;
21919         TALLOC_CTX *_mem_save_needed_0;
21920         if (flags & NDR_IN) {
21921                 ZERO_STRUCT(r->out);
21922
21923                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21924                         NDR_PULL_ALLOC(ndr, r->in.handle);
21925                 }
21926                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21927                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21928                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21929                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21930                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21931                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21932                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21933                         return 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));
21934                 }
21935                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21936                 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));
21937                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21938                 NDR_PULL_ALLOC(ndr, r->out.type);
21939                 ZERO_STRUCTP(r->out.type);
21940                 NDR_PULL_ALLOC(ndr, r->out.data);
21941                 ZERO_STRUCTP(r->out.data);
21942                 NDR_PULL_ALLOC(ndr, r->out.needed);
21943                 ZERO_STRUCTP(r->out.needed);
21944         }
21945         if (flags & NDR_OUT) {
21946                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21947                         NDR_PULL_ALLOC(ndr, r->out.type);
21948                 }
21949                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21950                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21951                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
21952                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21953                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21954                         NDR_PULL_ALLOC(ndr, r->out.data);
21955                 }
21956                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21957                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21958                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21959                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21960                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21961                         NDR_PULL_ALLOC(ndr, r->out.needed);
21962                 }
21963                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21964                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21966                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21967                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21968         }
21969         return NDR_ERR_SUCCESS;
21970 }
21971
21972 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21973 {
21974         if (flags & NDR_IN) {
21975                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21976         }
21977         if (flags & NDR_OUT) {
21978                 if (r->out.data == NULL) {
21979                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21980                 }
21981                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
21982                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21983         }
21984         return NDR_ERR_SUCCESS;
21985 }
21986
21987 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21988 {
21989         TALLOC_CTX *_mem_save_data_0;
21990         if (flags & NDR_IN) {
21991                 ZERO_STRUCT(r->out);
21992
21993                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
21994                 NDR_PULL_ALLOC(ndr, r->out.data);
21995                 ZERO_STRUCTP(r->out.data);
21996         }
21997         if (flags & NDR_OUT) {
21998                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21999                         NDR_PULL_ALLOC(ndr, r->out.data);
22000                 }
22001                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
22002                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
22003                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
22004                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
22006         }
22007         return NDR_ERR_SUCCESS;
22008 }
22009
22010 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
22011 {
22012         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
22013         ndr->depth++;
22014         if (flags & NDR_SET_VALUES) {
22015                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22016         }
22017         if (flags & NDR_IN) {
22018                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
22019                 ndr->depth++;
22020                 ndr_print_ptr(ndr, "handle", r->in.handle);
22021                 ndr->depth++;
22022                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22023                 ndr->depth--;
22024                 ndr_print_string(ndr, "value_name", r->in.value_name);
22025                 ndr_print_uint32(ndr, "offered", r->in.offered);
22026                 ndr->depth--;
22027         }
22028         if (flags & NDR_OUT) {
22029                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
22030                 ndr->depth++;
22031                 ndr_print_ptr(ndr, "type", r->out.type);
22032                 ndr->depth++;
22033                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
22034                 ndr->depth--;
22035                 ndr_print_ptr(ndr, "data", r->out.data);
22036                 ndr->depth++;
22037                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
22038                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
22039                 ndr->depth--;
22040                 ndr_print_ptr(ndr, "needed", r->out.needed);
22041                 ndr->depth++;
22042                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22043                 ndr->depth--;
22044                 ndr_print_WERROR(ndr, "result", r->out.result);
22045                 ndr->depth--;
22046         }
22047         ndr->depth--;
22048 }
22049
22050 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
22051 {
22052         if (flags & NDR_IN) {
22053                 if (r->in.handle == NULL) {
22054                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22055                 }
22056                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22059                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22060                 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));
22061                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22062                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
22064         }
22065         if (flags & NDR_OUT) {
22066                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22067         }
22068         return NDR_ERR_SUCCESS;
22069 }
22070
22071 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
22072 {
22073         if (flags & NDR_IN) {
22074                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22075         }
22076         if (flags & NDR_OUT) {
22077                 if (r->out.data == NULL) {
22078                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22079                 }
22080                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22081                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22082         }
22083         return NDR_ERR_SUCCESS;
22084 }
22085
22086 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
22087 {
22088         TALLOC_CTX *_mem_save_handle_0;
22089         if (flags & NDR_IN) {
22090                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22091                         NDR_PULL_ALLOC(ndr, r->in.handle);
22092                 }
22093                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22094                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22095                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22097                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22098                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22099                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22100                         return 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));
22101                 }
22102                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22103                 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));
22104                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22105                 {
22106                         struct ndr_pull *_ndr_data;
22107                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
22108                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
22109                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
22110                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
22111                 }
22112                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
22113         }
22114         if (flags & NDR_OUT) {
22115                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22116         }
22117         return NDR_ERR_SUCCESS;
22118 }
22119
22120 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
22121 {
22122         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
22123         ndr->depth++;
22124         if (flags & NDR_SET_VALUES) {
22125                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22126         }
22127         if (flags & NDR_IN) {
22128                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
22129                 ndr->depth++;
22130                 ndr_print_ptr(ndr, "handle", r->in.handle);
22131                 ndr->depth++;
22132                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22133                 ndr->depth--;
22134                 ndr_print_string(ndr, "value_name", r->in.value_name);
22135                 ndr_print_winreg_Type(ndr, "type", r->in.type);
22136                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
22137                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
22138                 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);
22139                 ndr->depth--;
22140         }
22141         if (flags & NDR_OUT) {
22142                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
22143                 ndr->depth++;
22144                 ndr_print_WERROR(ndr, "result", r->out.result);
22145                 ndr->depth--;
22146         }
22147         ndr->depth--;
22148 }
22149
22150 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
22151 {
22152         if (flags & NDR_IN) {
22153         }
22154         if (flags & NDR_OUT) {
22155                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22156         }
22157         return NDR_ERR_SUCCESS;
22158 }
22159
22160 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
22161 {
22162         if (flags & NDR_IN) {
22163         }
22164         if (flags & NDR_OUT) {
22165                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22166         }
22167         return NDR_ERR_SUCCESS;
22168 }
22169
22170 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
22171 {
22172         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
22173         ndr->depth++;
22174         if (flags & NDR_SET_VALUES) {
22175                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22176         }
22177         if (flags & NDR_IN) {
22178                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
22179                 ndr->depth++;
22180                 ndr->depth--;
22181         }
22182         if (flags & NDR_OUT) {
22183                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
22184                 ndr->depth++;
22185                 ndr_print_WERROR(ndr, "result", r->out.result);
22186                 ndr->depth--;
22187         }
22188         ndr->depth--;
22189 }
22190
22191 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
22192 {
22193         if (flags & NDR_IN) {
22194                 if (r->in.handle == NULL) {
22195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22196                 }
22197                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22198         }
22199         if (flags & NDR_OUT) {
22200                 if (r->out.handle == NULL) {
22201                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22202                 }
22203                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22204                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22205         }
22206         return NDR_ERR_SUCCESS;
22207 }
22208
22209 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
22210 {
22211         TALLOC_CTX *_mem_save_handle_0;
22212         if (flags & NDR_IN) {
22213                 ZERO_STRUCT(r->out);
22214
22215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22216                         NDR_PULL_ALLOC(ndr, r->in.handle);
22217                 }
22218                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22219                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22220                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22222                 NDR_PULL_ALLOC(ndr, r->out.handle);
22223                 *r->out.handle = *r->in.handle;
22224         }
22225         if (flags & NDR_OUT) {
22226                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22227                         NDR_PULL_ALLOC(ndr, r->out.handle);
22228                 }
22229                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22230                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22231                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22232                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22233                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22234         }
22235         return NDR_ERR_SUCCESS;
22236 }
22237
22238 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
22239 {
22240         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
22241         ndr->depth++;
22242         if (flags & NDR_SET_VALUES) {
22243                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22244         }
22245         if (flags & NDR_IN) {
22246                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
22247                 ndr->depth++;
22248                 ndr_print_ptr(ndr, "handle", r->in.handle);
22249                 ndr->depth++;
22250                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22251                 ndr->depth--;
22252                 ndr->depth--;
22253         }
22254         if (flags & NDR_OUT) {
22255                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
22256                 ndr->depth++;
22257                 ndr_print_ptr(ndr, "handle", r->out.handle);
22258                 ndr->depth++;
22259                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22260                 ndr->depth--;
22261                 ndr_print_WERROR(ndr, "result", r->out.result);
22262                 ndr->depth--;
22263         }
22264         ndr->depth--;
22265 }
22266
22267 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
22268 {
22269         if (flags & NDR_IN) {
22270                 if (r->in.handle == NULL) {
22271                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22272                 }
22273                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22275                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22276                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22277         }
22278         if (flags & NDR_OUT) {
22279                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22280         }
22281         return NDR_ERR_SUCCESS;
22282 }
22283
22284 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
22285 {
22286         TALLOC_CTX *_mem_save_handle_0;
22287         if (flags & NDR_IN) {
22288                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22289                         NDR_PULL_ALLOC(ndr, r->in.handle);
22290                 }
22291                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22292                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22293                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22294                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22295                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22296                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22297                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22298         }
22299         if (flags & NDR_OUT) {
22300                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22301         }
22302         return NDR_ERR_SUCCESS;
22303 }
22304
22305 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
22306 {
22307         ndr_print_struct(ndr, name, "spoolss_AddForm");
22308         ndr->depth++;
22309         if (flags & NDR_SET_VALUES) {
22310                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22311         }
22312         if (flags & NDR_IN) {
22313                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
22314                 ndr->depth++;
22315                 ndr_print_ptr(ndr, "handle", r->in.handle);
22316                 ndr->depth++;
22317                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22318                 ndr->depth--;
22319                 ndr_print_uint32(ndr, "level", r->in.level);
22320                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22321                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22322                 ndr->depth--;
22323         }
22324         if (flags & NDR_OUT) {
22325                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22326                 ndr->depth++;
22327                 ndr_print_WERROR(ndr, "result", r->out.result);
22328                 ndr->depth--;
22329         }
22330         ndr->depth--;
22331 }
22332
22333 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22334 {
22335         if (flags & NDR_IN) {
22336                 if (r->in.handle == NULL) {
22337                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22338                 }
22339                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22341                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22342                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22343                 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));
22344         }
22345         if (flags & NDR_OUT) {
22346                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22347         }
22348         return NDR_ERR_SUCCESS;
22349 }
22350
22351 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22352 {
22353         TALLOC_CTX *_mem_save_handle_0;
22354         if (flags & NDR_IN) {
22355                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22356                         NDR_PULL_ALLOC(ndr, r->in.handle);
22357                 }
22358                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22359                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22360                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22361                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22362                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22363                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22364                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22365                         return 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));
22366                 }
22367                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22368                 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));
22369         }
22370         if (flags & NDR_OUT) {
22371                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22372         }
22373         return NDR_ERR_SUCCESS;
22374 }
22375
22376 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22377 {
22378         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22379         ndr->depth++;
22380         if (flags & NDR_SET_VALUES) {
22381                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22382         }
22383         if (flags & NDR_IN) {
22384                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22385                 ndr->depth++;
22386                 ndr_print_ptr(ndr, "handle", r->in.handle);
22387                 ndr->depth++;
22388                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22389                 ndr->depth--;
22390                 ndr_print_string(ndr, "form_name", r->in.form_name);
22391                 ndr->depth--;
22392         }
22393         if (flags & NDR_OUT) {
22394                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22395                 ndr->depth++;
22396                 ndr_print_WERROR(ndr, "result", r->out.result);
22397                 ndr->depth--;
22398         }
22399         ndr->depth--;
22400 }
22401
22402 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22403 {
22404         if (flags & NDR_IN) {
22405                 if (r->in.handle == NULL) {
22406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22407                 }
22408                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22409                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22410                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22411                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22412                 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));
22413                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22414                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22415                 if (r->in.buffer) {
22416                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22417                 }
22418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22419         }
22420         if (flags & NDR_OUT) {
22421                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22422                 if (r->out.info) {
22423                         {
22424                                 struct ndr_push *_ndr_info;
22425                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22426                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22427                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22428                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22429                         }
22430                 }
22431                 if (r->out.needed == NULL) {
22432                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22433                 }
22434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22435                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22436         }
22437         return NDR_ERR_SUCCESS;
22438 }
22439
22440 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22441 {
22442         uint32_t _ptr_buffer;
22443         uint32_t _ptr_info;
22444         TALLOC_CTX *_mem_save_handle_0;
22445         TALLOC_CTX *_mem_save_buffer_0;
22446         TALLOC_CTX *_mem_save_info_0;
22447         TALLOC_CTX *_mem_save_needed_0;
22448         if (flags & NDR_IN) {
22449                 ZERO_STRUCT(r->out);
22450
22451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22452                         NDR_PULL_ALLOC(ndr, r->in.handle);
22453                 }
22454                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22455                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22456                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22458                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22459                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22460                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22461                         return 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));
22462                 }
22463                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22464                 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));
22465                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22466                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22467                 if (_ptr_buffer) {
22468                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22469                 } else {
22470                         r->in.buffer = NULL;
22471                 }
22472                 if (r->in.buffer) {
22473                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22474                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22475                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22476                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22477                 }
22478                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22479                 NDR_PULL_ALLOC(ndr, r->out.needed);
22480                 ZERO_STRUCTP(r->out.needed);
22481         }
22482         if (flags & NDR_OUT) {
22483                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22484                 if (_ptr_info) {
22485                         NDR_PULL_ALLOC(ndr, r->out.info);
22486                 } else {
22487                         r->out.info = NULL;
22488                 }
22489                 if (r->out.info) {
22490                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22491                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22492                         {
22493                                 struct ndr_pull *_ndr_info;
22494                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22495                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22496                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22497                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22498                         }
22499                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22500                 }
22501                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22502                         NDR_PULL_ALLOC(ndr, r->out.needed);
22503                 }
22504                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22505                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22506                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22507                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22508                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22509         }
22510         return NDR_ERR_SUCCESS;
22511 }
22512
22513 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22514 {
22515         ndr_print_struct(ndr, name, "spoolss_GetForm");
22516         ndr->depth++;
22517         if (flags & NDR_SET_VALUES) {
22518                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22519         }
22520         if (flags & NDR_IN) {
22521                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22522                 ndr->depth++;
22523                 ndr_print_ptr(ndr, "handle", r->in.handle);
22524                 ndr->depth++;
22525                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22526                 ndr->depth--;
22527                 ndr_print_string(ndr, "form_name", r->in.form_name);
22528                 ndr_print_uint32(ndr, "level", r->in.level);
22529                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22530                 ndr->depth++;
22531                 if (r->in.buffer) {
22532                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22533                 }
22534                 ndr->depth--;
22535                 ndr_print_uint32(ndr, "offered", r->in.offered);
22536                 ndr->depth--;
22537         }
22538         if (flags & NDR_OUT) {
22539                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22540                 ndr->depth++;
22541                 ndr_print_ptr(ndr, "info", r->out.info);
22542                 ndr->depth++;
22543                 if (r->out.info) {
22544                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22545                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22546                 }
22547                 ndr->depth--;
22548                 ndr_print_ptr(ndr, "needed", r->out.needed);
22549                 ndr->depth++;
22550                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22551                 ndr->depth--;
22552                 ndr_print_WERROR(ndr, "result", r->out.result);
22553                 ndr->depth--;
22554         }
22555         ndr->depth--;
22556 }
22557
22558 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22559 {
22560         if (flags & NDR_IN) {
22561                 if (r->in.handle == NULL) {
22562                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22563                 }
22564                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22565                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22566                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22567                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22568                 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));
22569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22570                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22571                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22572         }
22573         if (flags & NDR_OUT) {
22574                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22575         }
22576         return NDR_ERR_SUCCESS;
22577 }
22578
22579 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22580 {
22581         TALLOC_CTX *_mem_save_handle_0;
22582         if (flags & NDR_IN) {
22583                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22584                         NDR_PULL_ALLOC(ndr, r->in.handle);
22585                 }
22586                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22587                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22588                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22589                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22590                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22591                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22592                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22593                         return 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));
22594                 }
22595                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22596                 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));
22597                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22598                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22599                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22600         }
22601         if (flags & NDR_OUT) {
22602                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22603         }
22604         return NDR_ERR_SUCCESS;
22605 }
22606
22607 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22608 {
22609         ndr_print_struct(ndr, name, "spoolss_SetForm");
22610         ndr->depth++;
22611         if (flags & NDR_SET_VALUES) {
22612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22613         }
22614         if (flags & NDR_IN) {
22615                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22616                 ndr->depth++;
22617                 ndr_print_ptr(ndr, "handle", r->in.handle);
22618                 ndr->depth++;
22619                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22620                 ndr->depth--;
22621                 ndr_print_string(ndr, "form_name", r->in.form_name);
22622                 ndr_print_uint32(ndr, "level", r->in.level);
22623                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22624                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22625                 ndr->depth--;
22626         }
22627         if (flags & NDR_OUT) {
22628                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22629                 ndr->depth++;
22630                 ndr_print_WERROR(ndr, "result", r->out.result);
22631                 ndr->depth--;
22632         }
22633         ndr->depth--;
22634 }
22635
22636 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22637 {
22638         if (flags & NDR_IN) {
22639                 if (r->in.handle == NULL) {
22640                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22641                 }
22642                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22644                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22645                 if (r->in.buffer) {
22646                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22647                 }
22648                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22649         }
22650         if (flags & NDR_OUT) {
22651                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22652                 if (r->out.info) {
22653                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22654                 }
22655                 if (r->out.needed == NULL) {
22656                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22657                 }
22658                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22659                 if (r->out.count == NULL) {
22660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22661                 }
22662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22663                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22664         }
22665         return NDR_ERR_SUCCESS;
22666 }
22667
22668 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22669 {
22670         uint32_t _ptr_buffer;
22671         uint32_t _ptr_info;
22672         TALLOC_CTX *_mem_save_handle_0;
22673         TALLOC_CTX *_mem_save_buffer_0;
22674         TALLOC_CTX *_mem_save_info_0;
22675         TALLOC_CTX *_mem_save_needed_0;
22676         TALLOC_CTX *_mem_save_count_0;
22677         if (flags & NDR_IN) {
22678                 ZERO_STRUCT(r->out);
22679
22680                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22681                         NDR_PULL_ALLOC(ndr, r->in.handle);
22682                 }
22683                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22684                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22685                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22686                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22687                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22688                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22689                 if (_ptr_buffer) {
22690                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22691                 } else {
22692                         r->in.buffer = NULL;
22693                 }
22694                 if (r->in.buffer) {
22695                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22696                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22697                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22699                 }
22700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22701                 NDR_PULL_ALLOC(ndr, r->out.needed);
22702                 ZERO_STRUCTP(r->out.needed);
22703                 NDR_PULL_ALLOC(ndr, r->out.count);
22704                 ZERO_STRUCTP(r->out.count);
22705         }
22706         if (flags & NDR_OUT) {
22707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22708                 if (_ptr_info) {
22709                         NDR_PULL_ALLOC(ndr, r->out.info);
22710                 } else {
22711                         r->out.info = NULL;
22712                 }
22713                 if (r->out.info) {
22714                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22715                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22716                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22717                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22718                 }
22719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22720                         NDR_PULL_ALLOC(ndr, r->out.needed);
22721                 }
22722                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22723                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22724                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22726                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22727                         NDR_PULL_ALLOC(ndr, r->out.count);
22728                 }
22729                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22730                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22732                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22733                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22734         }
22735         return NDR_ERR_SUCCESS;
22736 }
22737
22738 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22739 {
22740         uint32_t cntr_info_0;
22741         if (flags & NDR_IN) {
22742                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22743                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22744         }
22745         if (flags & NDR_OUT) {
22746                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22747                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22748                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22749                 }
22750                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22751                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22752                 }
22753         }
22754         return NDR_ERR_SUCCESS;
22755 }
22756
22757 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22758 {
22759         uint32_t cntr_info_0;
22760         TALLOC_CTX *_mem_save_info_0;
22761         if (flags & NDR_IN) {
22762                 ZERO_STRUCT(r->out);
22763
22764                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22765                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22766         }
22767         if (flags & NDR_OUT) {
22768                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22769                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22770                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22771                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22772                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22773                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22774                 }
22775                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22776                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22777                 }
22778                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22779         }
22780         return NDR_ERR_SUCCESS;
22781 }
22782
22783 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22784 {
22785         uint32_t cntr_info_2;
22786         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22787         ndr->depth++;
22788         if (flags & NDR_SET_VALUES) {
22789                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22790         }
22791         if (flags & NDR_IN) {
22792                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22793                 ndr->depth++;
22794                 ndr_print_ptr(ndr, "handle", r->in.handle);
22795                 ndr->depth++;
22796                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22797                 ndr->depth--;
22798                 ndr_print_uint32(ndr, "level", r->in.level);
22799                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22800                 ndr->depth++;
22801                 if (r->in.buffer) {
22802                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22803                 }
22804                 ndr->depth--;
22805                 ndr_print_uint32(ndr, "offered", r->in.offered);
22806                 ndr->depth--;
22807         }
22808         if (flags & NDR_OUT) {
22809                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22810                 ndr->depth++;
22811                 ndr_print_ptr(ndr, "count", r->out.count);
22812                 ndr->depth++;
22813                 ndr_print_uint32(ndr, "count", *r->out.count);
22814                 ndr->depth--;
22815                 ndr_print_ptr(ndr, "info", r->out.info);
22816                 ndr->depth++;
22817                 ndr_print_ptr(ndr, "info", *r->out.info);
22818                 ndr->depth++;
22819                 if (*r->out.info) {
22820                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22821                         ndr->depth++;
22822                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22823                                 char *idx_2=NULL;
22824                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22825                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22826                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22827                                         free(idx_2);
22828                                 }
22829                         }
22830                         ndr->depth--;
22831                 }
22832                 ndr->depth--;
22833                 ndr->depth--;
22834                 ndr_print_ptr(ndr, "needed", r->out.needed);
22835                 ndr->depth++;
22836                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22837                 ndr->depth--;
22838                 ndr_print_WERROR(ndr, "result", r->out.result);
22839                 ndr->depth--;
22840         }
22841         ndr->depth--;
22842 }
22843
22844 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22845 {
22846         if (flags & NDR_IN) {
22847                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22848                 if (r->in.servername) {
22849                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22852                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22853                 }
22854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22855                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22856                 if (r->in.buffer) {
22857                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22858                 }
22859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22860         }
22861         if (flags & NDR_OUT) {
22862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22863                 if (r->out.info) {
22864                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22865                 }
22866                 if (r->out.needed == NULL) {
22867                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22868                 }
22869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22870                 if (r->out.count == NULL) {
22871                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22872                 }
22873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22874                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22875         }
22876         return NDR_ERR_SUCCESS;
22877 }
22878
22879 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22880 {
22881         uint32_t _ptr_servername;
22882         uint32_t _ptr_buffer;
22883         uint32_t _ptr_info;
22884         TALLOC_CTX *_mem_save_servername_0;
22885         TALLOC_CTX *_mem_save_buffer_0;
22886         TALLOC_CTX *_mem_save_info_0;
22887         TALLOC_CTX *_mem_save_needed_0;
22888         TALLOC_CTX *_mem_save_count_0;
22889         if (flags & NDR_IN) {
22890                 ZERO_STRUCT(r->out);
22891
22892                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22893                 if (_ptr_servername) {
22894                         NDR_PULL_ALLOC(ndr, r->in.servername);
22895                 } else {
22896                         r->in.servername = NULL;
22897                 }
22898                 if (r->in.servername) {
22899                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22900                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22901                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22902                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22903                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22904                                 return 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));
22905                         }
22906                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22907                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22908                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22909                 }
22910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22911                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22912                 if (_ptr_buffer) {
22913                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22914                 } else {
22915                         r->in.buffer = NULL;
22916                 }
22917                 if (r->in.buffer) {
22918                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22919                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22920                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22921                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22922                 }
22923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22924                 NDR_PULL_ALLOC(ndr, r->out.needed);
22925                 ZERO_STRUCTP(r->out.needed);
22926                 NDR_PULL_ALLOC(ndr, r->out.count);
22927                 ZERO_STRUCTP(r->out.count);
22928         }
22929         if (flags & NDR_OUT) {
22930                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22931                 if (_ptr_info) {
22932                         NDR_PULL_ALLOC(ndr, r->out.info);
22933                 } else {
22934                         r->out.info = NULL;
22935                 }
22936                 if (r->out.info) {
22937                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22938                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22939                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22940                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22941                 }
22942                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22943                         NDR_PULL_ALLOC(ndr, r->out.needed);
22944                 }
22945                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22946                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22947                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22948                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22949                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22950                         NDR_PULL_ALLOC(ndr, r->out.count);
22951                 }
22952                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22953                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22954                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22955                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22956                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22957         }
22958         return NDR_ERR_SUCCESS;
22959 }
22960
22961 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22962 {
22963         uint32_t cntr_info_0;
22964         if (flags & NDR_IN) {
22965                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22966                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22967         }
22968         if (flags & NDR_OUT) {
22969                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22970                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22971                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22972                 }
22973                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22974                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22975                 }
22976         }
22977         return NDR_ERR_SUCCESS;
22978 }
22979
22980 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22981 {
22982         uint32_t cntr_info_0;
22983         TALLOC_CTX *_mem_save_info_0;
22984         if (flags & NDR_IN) {
22985                 ZERO_STRUCT(r->out);
22986
22987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22988                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22989         }
22990         if (flags & NDR_OUT) {
22991                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22992                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22993                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22994                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22995                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22996                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22997                 }
22998                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22999                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23000                 }
23001                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23002         }
23003         return NDR_ERR_SUCCESS;
23004 }
23005
23006 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
23007 {
23008         uint32_t cntr_info_2;
23009         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
23010         ndr->depth++;
23011         if (flags & NDR_SET_VALUES) {
23012                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23013         }
23014         if (flags & NDR_IN) {
23015                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
23016                 ndr->depth++;
23017                 ndr_print_ptr(ndr, "servername", r->in.servername);
23018                 ndr->depth++;
23019                 if (r->in.servername) {
23020                         ndr_print_string(ndr, "servername", r->in.servername);
23021                 }
23022                 ndr->depth--;
23023                 ndr_print_uint32(ndr, "level", r->in.level);
23024                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23025                 ndr->depth++;
23026                 if (r->in.buffer) {
23027                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23028                 }
23029                 ndr->depth--;
23030                 ndr_print_uint32(ndr, "offered", r->in.offered);
23031                 ndr->depth--;
23032         }
23033         if (flags & NDR_OUT) {
23034                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
23035                 ndr->depth++;
23036                 ndr_print_ptr(ndr, "count", r->out.count);
23037                 ndr->depth++;
23038                 ndr_print_uint32(ndr, "count", *r->out.count);
23039                 ndr->depth--;
23040                 ndr_print_ptr(ndr, "info", r->out.info);
23041                 ndr->depth++;
23042                 ndr_print_ptr(ndr, "info", *r->out.info);
23043                 ndr->depth++;
23044                 if (*r->out.info) {
23045                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23046                         ndr->depth++;
23047                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23048                                 char *idx_2=NULL;
23049                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23050                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23051                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23052                                         free(idx_2);
23053                                 }
23054                         }
23055                         ndr->depth--;
23056                 }
23057                 ndr->depth--;
23058                 ndr->depth--;
23059                 ndr_print_ptr(ndr, "needed", r->out.needed);
23060                 ndr->depth++;
23061                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23062                 ndr->depth--;
23063                 ndr_print_WERROR(ndr, "result", r->out.result);
23064                 ndr->depth--;
23065         }
23066         ndr->depth--;
23067 }
23068
23069 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
23070 {
23071         if (flags & NDR_IN) {
23072                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23073                 if (r->in.servername) {
23074                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23075                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23076                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23077                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23078                 }
23079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23080                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23081                 if (r->in.buffer) {
23082                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23083                 }
23084                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23085         }
23086         if (flags & NDR_OUT) {
23087                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23088                 if (r->out.info) {
23089                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23090                 }
23091                 if (r->out.needed == NULL) {
23092                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23093                 }
23094                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23095                 if (r->out.count == NULL) {
23096                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23097                 }
23098                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23099                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23100         }
23101         return NDR_ERR_SUCCESS;
23102 }
23103
23104 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
23105 {
23106         uint32_t _ptr_servername;
23107         uint32_t _ptr_buffer;
23108         uint32_t _ptr_info;
23109         TALLOC_CTX *_mem_save_servername_0;
23110         TALLOC_CTX *_mem_save_buffer_0;
23111         TALLOC_CTX *_mem_save_info_0;
23112         TALLOC_CTX *_mem_save_needed_0;
23113         TALLOC_CTX *_mem_save_count_0;
23114         if (flags & NDR_IN) {
23115                 ZERO_STRUCT(r->out);
23116
23117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23118                 if (_ptr_servername) {
23119                         NDR_PULL_ALLOC(ndr, r->in.servername);
23120                 } else {
23121                         r->in.servername = NULL;
23122                 }
23123                 if (r->in.servername) {
23124                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23125                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23126                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23127                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23128                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23129                                 return 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));
23130                         }
23131                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23132                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23134                 }
23135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23137                 if (_ptr_buffer) {
23138                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23139                 } else {
23140                         r->in.buffer = NULL;
23141                 }
23142                 if (r->in.buffer) {
23143                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23144                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23145                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23147                 }
23148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23149                 NDR_PULL_ALLOC(ndr, r->out.needed);
23150                 ZERO_STRUCTP(r->out.needed);
23151                 NDR_PULL_ALLOC(ndr, r->out.count);
23152                 ZERO_STRUCTP(r->out.count);
23153         }
23154         if (flags & NDR_OUT) {
23155                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23156                 if (_ptr_info) {
23157                         NDR_PULL_ALLOC(ndr, r->out.info);
23158                 } else {
23159                         r->out.info = NULL;
23160                 }
23161                 if (r->out.info) {
23162                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23163                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23164                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23165                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23166                 }
23167                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23168                         NDR_PULL_ALLOC(ndr, r->out.needed);
23169                 }
23170                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23171                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23172                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23173                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23174                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23175                         NDR_PULL_ALLOC(ndr, r->out.count);
23176                 }
23177                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23178                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23179                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23180                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23181                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23182         }
23183         return NDR_ERR_SUCCESS;
23184 }
23185
23186 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
23187 {
23188         uint32_t cntr_info_0;
23189         if (flags & NDR_IN) {
23190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23191                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23192         }
23193         if (flags & NDR_OUT) {
23194                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23195                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23196                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23197                 }
23198                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23199                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23200                 }
23201         }
23202         return NDR_ERR_SUCCESS;
23203 }
23204
23205 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
23206 {
23207         uint32_t cntr_info_0;
23208         TALLOC_CTX *_mem_save_info_0;
23209         if (flags & NDR_IN) {
23210                 ZERO_STRUCT(r->out);
23211
23212                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23213                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23214         }
23215         if (flags & NDR_OUT) {
23216                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23217                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23218                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23219                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23220                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23221                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23222                 }
23223                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23224                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23225                 }
23226                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23227         }
23228         return NDR_ERR_SUCCESS;
23229 }
23230
23231 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
23232 {
23233         uint32_t cntr_info_2;
23234         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
23235         ndr->depth++;
23236         if (flags & NDR_SET_VALUES) {
23237                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23238         }
23239         if (flags & NDR_IN) {
23240                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
23241                 ndr->depth++;
23242                 ndr_print_ptr(ndr, "servername", r->in.servername);
23243                 ndr->depth++;
23244                 if (r->in.servername) {
23245                         ndr_print_string(ndr, "servername", r->in.servername);
23246                 }
23247                 ndr->depth--;
23248                 ndr_print_uint32(ndr, "level", r->in.level);
23249                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23250                 ndr->depth++;
23251                 if (r->in.buffer) {
23252                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23253                 }
23254                 ndr->depth--;
23255                 ndr_print_uint32(ndr, "offered", r->in.offered);
23256                 ndr->depth--;
23257         }
23258         if (flags & NDR_OUT) {
23259                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
23260                 ndr->depth++;
23261                 ndr_print_ptr(ndr, "count", r->out.count);
23262                 ndr->depth++;
23263                 ndr_print_uint32(ndr, "count", *r->out.count);
23264                 ndr->depth--;
23265                 ndr_print_ptr(ndr, "info", r->out.info);
23266                 ndr->depth++;
23267                 ndr_print_ptr(ndr, "info", *r->out.info);
23268                 ndr->depth++;
23269                 if (*r->out.info) {
23270                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23271                         ndr->depth++;
23272                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23273                                 char *idx_2=NULL;
23274                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23275                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23276                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23277                                         free(idx_2);
23278                                 }
23279                         }
23280                         ndr->depth--;
23281                 }
23282                 ndr->depth--;
23283                 ndr->depth--;
23284                 ndr_print_ptr(ndr, "needed", r->out.needed);
23285                 ndr->depth++;
23286                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23287                 ndr->depth--;
23288                 ndr_print_WERROR(ndr, "result", r->out.result);
23289                 ndr->depth--;
23290         }
23291         ndr->depth--;
23292 }
23293
23294 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
23295 {
23296         if (flags & NDR_IN) {
23297                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
23298                 if (r->in.server_name) {
23299                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23300                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23301                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23302                         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));
23303                 }
23304                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
23305                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23306                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23307                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23308                 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));
23309         }
23310         if (flags & NDR_OUT) {
23311                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23312         }
23313         return NDR_ERR_SUCCESS;
23314 }
23315
23316 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23317 {
23318         uint32_t _ptr_server_name;
23319         TALLOC_CTX *_mem_save_server_name_0;
23320         if (flags & NDR_IN) {
23321                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23322                 if (_ptr_server_name) {
23323                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23324                 } else {
23325                         r->in.server_name = NULL;
23326                 }
23327                 if (r->in.server_name) {
23328                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23329                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23330                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23331                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23332                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23333                                 return 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));
23334                         }
23335                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23336                         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));
23337                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23338                 }
23339                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23340                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23341                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23342                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23343                         return 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));
23344                 }
23345                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23346                 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));
23347         }
23348         if (flags & NDR_OUT) {
23349                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23350         }
23351         return NDR_ERR_SUCCESS;
23352 }
23353
23354 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23355 {
23356         ndr_print_struct(ndr, name, "spoolss_AddPort");
23357         ndr->depth++;
23358         if (flags & NDR_SET_VALUES) {
23359                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23360         }
23361         if (flags & NDR_IN) {
23362                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23363                 ndr->depth++;
23364                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23365                 ndr->depth++;
23366                 if (r->in.server_name) {
23367                         ndr_print_string(ndr, "server_name", r->in.server_name);
23368                 }
23369                 ndr->depth--;
23370                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23371                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23372                 ndr->depth--;
23373         }
23374         if (flags & NDR_OUT) {
23375                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23376                 ndr->depth++;
23377                 ndr_print_WERROR(ndr, "result", r->out.result);
23378                 ndr->depth--;
23379         }
23380         ndr->depth--;
23381 }
23382
23383 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23384 {
23385         if (flags & NDR_IN) {
23386         }
23387         if (flags & NDR_OUT) {
23388                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23389         }
23390         return NDR_ERR_SUCCESS;
23391 }
23392
23393 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23394 {
23395         if (flags & NDR_IN) {
23396         }
23397         if (flags & NDR_OUT) {
23398                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23399         }
23400         return NDR_ERR_SUCCESS;
23401 }
23402
23403 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23404 {
23405         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23406         ndr->depth++;
23407         if (flags & NDR_SET_VALUES) {
23408                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23409         }
23410         if (flags & NDR_IN) {
23411                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23412                 ndr->depth++;
23413                 ndr->depth--;
23414         }
23415         if (flags & NDR_OUT) {
23416                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23417                 ndr->depth++;
23418                 ndr_print_WERROR(ndr, "result", r->out.result);
23419                 ndr->depth--;
23420         }
23421         ndr->depth--;
23422 }
23423
23424 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23425 {
23426         if (flags & NDR_IN) {
23427         }
23428         if (flags & NDR_OUT) {
23429                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23430         }
23431         return NDR_ERR_SUCCESS;
23432 }
23433
23434 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23435 {
23436         if (flags & NDR_IN) {
23437         }
23438         if (flags & NDR_OUT) {
23439                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23440         }
23441         return NDR_ERR_SUCCESS;
23442 }
23443
23444 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23445 {
23446         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23447         ndr->depth++;
23448         if (flags & NDR_SET_VALUES) {
23449                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23450         }
23451         if (flags & NDR_IN) {
23452                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23453                 ndr->depth++;
23454                 ndr->depth--;
23455         }
23456         if (flags & NDR_OUT) {
23457                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23458                 ndr->depth++;
23459                 ndr_print_WERROR(ndr, "result", r->out.result);
23460                 ndr->depth--;
23461         }
23462         ndr->depth--;
23463 }
23464
23465 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23466 {
23467         if (flags & NDR_IN) {
23468         }
23469         if (flags & NDR_OUT) {
23470                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23471         }
23472         return NDR_ERR_SUCCESS;
23473 }
23474
23475 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23476 {
23477         if (flags & NDR_IN) {
23478         }
23479         if (flags & NDR_OUT) {
23480                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23481         }
23482         return NDR_ERR_SUCCESS;
23483 }
23484
23485 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23486 {
23487         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23488         ndr->depth++;
23489         if (flags & NDR_SET_VALUES) {
23490                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23491         }
23492         if (flags & NDR_IN) {
23493                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23494                 ndr->depth++;
23495                 ndr->depth--;
23496         }
23497         if (flags & NDR_OUT) {
23498                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23499                 ndr->depth++;
23500                 ndr_print_WERROR(ndr, "result", r->out.result);
23501                 ndr->depth--;
23502         }
23503         ndr->depth--;
23504 }
23505
23506 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23507 {
23508         if (flags & NDR_IN) {
23509         }
23510         if (flags & NDR_OUT) {
23511                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23512         }
23513         return NDR_ERR_SUCCESS;
23514 }
23515
23516 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23517 {
23518         if (flags & NDR_IN) {
23519         }
23520         if (flags & NDR_OUT) {
23521                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23522         }
23523         return NDR_ERR_SUCCESS;
23524 }
23525
23526 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23527 {
23528         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23529         ndr->depth++;
23530         if (flags & NDR_SET_VALUES) {
23531                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23532         }
23533         if (flags & NDR_IN) {
23534                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23535                 ndr->depth++;
23536                 ndr->depth--;
23537         }
23538         if (flags & NDR_OUT) {
23539                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23540                 ndr->depth++;
23541                 ndr_print_WERROR(ndr, "result", r->out.result);
23542                 ndr->depth--;
23543         }
23544         ndr->depth--;
23545 }
23546
23547 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23548 {
23549         if (flags & NDR_IN) {
23550         }
23551         if (flags & NDR_OUT) {
23552                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23553         }
23554         return NDR_ERR_SUCCESS;
23555 }
23556
23557 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23558 {
23559         if (flags & NDR_IN) {
23560         }
23561         if (flags & NDR_OUT) {
23562                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23563         }
23564         return NDR_ERR_SUCCESS;
23565 }
23566
23567 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23568 {
23569         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23570         ndr->depth++;
23571         if (flags & NDR_SET_VALUES) {
23572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23573         }
23574         if (flags & NDR_IN) {
23575                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23576                 ndr->depth++;
23577                 ndr->depth--;
23578         }
23579         if (flags & NDR_OUT) {
23580                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23581                 ndr->depth++;
23582                 ndr_print_WERROR(ndr, "result", r->out.result);
23583                 ndr->depth--;
23584         }
23585         ndr->depth--;
23586 }
23587
23588 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23589 {
23590         if (flags & NDR_IN) {
23591         }
23592         if (flags & NDR_OUT) {
23593                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23594         }
23595         return NDR_ERR_SUCCESS;
23596 }
23597
23598 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23599 {
23600         if (flags & NDR_IN) {
23601         }
23602         if (flags & NDR_OUT) {
23603                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23604         }
23605         return NDR_ERR_SUCCESS;
23606 }
23607
23608 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23609 {
23610         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23611         ndr->depth++;
23612         if (flags & NDR_SET_VALUES) {
23613                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23614         }
23615         if (flags & NDR_IN) {
23616                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23617                 ndr->depth++;
23618                 ndr->depth--;
23619         }
23620         if (flags & NDR_OUT) {
23621                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23622                 ndr->depth++;
23623                 ndr_print_WERROR(ndr, "result", r->out.result);
23624                 ndr->depth--;
23625         }
23626         ndr->depth--;
23627 }
23628
23629 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23630 {
23631         if (flags & NDR_IN) {
23632         }
23633         if (flags & NDR_OUT) {
23634                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23635         }
23636         return NDR_ERR_SUCCESS;
23637 }
23638
23639 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23640 {
23641         if (flags & NDR_IN) {
23642         }
23643         if (flags & NDR_OUT) {
23644                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23645         }
23646         return NDR_ERR_SUCCESS;
23647 }
23648
23649 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23650 {
23651         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23652         ndr->depth++;
23653         if (flags & NDR_SET_VALUES) {
23654                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23655         }
23656         if (flags & NDR_IN) {
23657                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23658                 ndr->depth++;
23659                 ndr->depth--;
23660         }
23661         if (flags & NDR_OUT) {
23662                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23663                 ndr->depth++;
23664                 ndr_print_WERROR(ndr, "result", r->out.result);
23665                 ndr->depth--;
23666         }
23667         ndr->depth--;
23668 }
23669
23670 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23671 {
23672         if (flags & NDR_IN) {
23673         }
23674         if (flags & NDR_OUT) {
23675                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23676         }
23677         return NDR_ERR_SUCCESS;
23678 }
23679
23680 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23681 {
23682         if (flags & NDR_IN) {
23683         }
23684         if (flags & NDR_OUT) {
23685                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23686         }
23687         return NDR_ERR_SUCCESS;
23688 }
23689
23690 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23691 {
23692         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23693         ndr->depth++;
23694         if (flags & NDR_SET_VALUES) {
23695                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23696         }
23697         if (flags & NDR_IN) {
23698                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23699                 ndr->depth++;
23700                 ndr->depth--;
23701         }
23702         if (flags & NDR_OUT) {
23703                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23704                 ndr->depth++;
23705                 ndr_print_WERROR(ndr, "result", r->out.result);
23706                 ndr->depth--;
23707         }
23708         ndr->depth--;
23709 }
23710
23711 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23712 {
23713         if (flags & NDR_IN) {
23714         }
23715         if (flags & NDR_OUT) {
23716                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23717         }
23718         return NDR_ERR_SUCCESS;
23719 }
23720
23721 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23722 {
23723         if (flags & NDR_IN) {
23724         }
23725         if (flags & NDR_OUT) {
23726                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23727         }
23728         return NDR_ERR_SUCCESS;
23729 }
23730
23731 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23732 {
23733         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23734         ndr->depth++;
23735         if (flags & NDR_SET_VALUES) {
23736                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23737         }
23738         if (flags & NDR_IN) {
23739                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23740                 ndr->depth++;
23741                 ndr->depth--;
23742         }
23743         if (flags & NDR_OUT) {
23744                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23745                 ndr->depth++;
23746                 ndr_print_WERROR(ndr, "result", r->out.result);
23747                 ndr->depth--;
23748         }
23749         ndr->depth--;
23750 }
23751
23752 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23753 {
23754         if (flags & NDR_IN) {
23755         }
23756         if (flags & NDR_OUT) {
23757                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23758         }
23759         return NDR_ERR_SUCCESS;
23760 }
23761
23762 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23763 {
23764         if (flags & NDR_IN) {
23765         }
23766         if (flags & NDR_OUT) {
23767                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23768         }
23769         return NDR_ERR_SUCCESS;
23770 }
23771
23772 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23773 {
23774         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23775         ndr->depth++;
23776         if (flags & NDR_SET_VALUES) {
23777                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23778         }
23779         if (flags & NDR_IN) {
23780                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23781                 ndr->depth++;
23782                 ndr->depth--;
23783         }
23784         if (flags & NDR_OUT) {
23785                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23786                 ndr->depth++;
23787                 ndr_print_WERROR(ndr, "result", r->out.result);
23788                 ndr->depth--;
23789         }
23790         ndr->depth--;
23791 }
23792
23793 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23794 {
23795         if (flags & NDR_IN) {
23796         }
23797         if (flags & NDR_OUT) {
23798                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23799         }
23800         return NDR_ERR_SUCCESS;
23801 }
23802
23803 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23804 {
23805         if (flags & NDR_IN) {
23806         }
23807         if (flags & NDR_OUT) {
23808                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23809         }
23810         return NDR_ERR_SUCCESS;
23811 }
23812
23813 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23814 {
23815         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23816         ndr->depth++;
23817         if (flags & NDR_SET_VALUES) {
23818                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23819         }
23820         if (flags & NDR_IN) {
23821                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23822                 ndr->depth++;
23823                 ndr->depth--;
23824         }
23825         if (flags & NDR_OUT) {
23826                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23827                 ndr->depth++;
23828                 ndr_print_WERROR(ndr, "result", r->out.result);
23829                 ndr->depth--;
23830         }
23831         ndr->depth--;
23832 }
23833
23834 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23835 {
23836         if (flags & NDR_IN) {
23837         }
23838         if (flags & NDR_OUT) {
23839                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23840         }
23841         return NDR_ERR_SUCCESS;
23842 }
23843
23844 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23845 {
23846         if (flags & NDR_IN) {
23847         }
23848         if (flags & NDR_OUT) {
23849                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23850         }
23851         return NDR_ERR_SUCCESS;
23852 }
23853
23854 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23855 {
23856         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23857         ndr->depth++;
23858         if (flags & NDR_SET_VALUES) {
23859                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23860         }
23861         if (flags & NDR_IN) {
23862                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23863                 ndr->depth++;
23864                 ndr->depth--;
23865         }
23866         if (flags & NDR_OUT) {
23867                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23868                 ndr->depth++;
23869                 ndr_print_WERROR(ndr, "result", r->out.result);
23870                 ndr->depth--;
23871         }
23872         ndr->depth--;
23873 }
23874
23875 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23876 {
23877         if (flags & NDR_IN) {
23878         }
23879         if (flags & NDR_OUT) {
23880                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23881         }
23882         return NDR_ERR_SUCCESS;
23883 }
23884
23885 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23886 {
23887         if (flags & NDR_IN) {
23888         }
23889         if (flags & NDR_OUT) {
23890                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23891         }
23892         return NDR_ERR_SUCCESS;
23893 }
23894
23895 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23896 {
23897         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23898         ndr->depth++;
23899         if (flags & NDR_SET_VALUES) {
23900                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23901         }
23902         if (flags & NDR_IN) {
23903                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23904                 ndr->depth++;
23905                 ndr->depth--;
23906         }
23907         if (flags & NDR_OUT) {
23908                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23909                 ndr->depth++;
23910                 ndr_print_WERROR(ndr, "result", r->out.result);
23911                 ndr->depth--;
23912         }
23913         ndr->depth--;
23914 }
23915
23916 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23917 {
23918         if (flags & NDR_IN) {
23919                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23920                 if (r->in.servername) {
23921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23924                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23925                 }
23926                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23927                 if (r->in.print_processor_name) {
23928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23930                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23931                         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));
23932                 }
23933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23934                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23935                 if (r->in.buffer) {
23936                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23937                 }
23938                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23939         }
23940         if (flags & NDR_OUT) {
23941                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23942                 if (r->out.info) {
23943                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23944                 }
23945                 if (r->out.needed == NULL) {
23946                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23947                 }
23948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23949                 if (r->out.count == NULL) {
23950                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23951                 }
23952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23953                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23954         }
23955         return NDR_ERR_SUCCESS;
23956 }
23957
23958 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23959 {
23960         uint32_t _ptr_servername;
23961         uint32_t _ptr_print_processor_name;
23962         uint32_t _ptr_buffer;
23963         uint32_t _ptr_info;
23964         TALLOC_CTX *_mem_save_servername_0;
23965         TALLOC_CTX *_mem_save_print_processor_name_0;
23966         TALLOC_CTX *_mem_save_buffer_0;
23967         TALLOC_CTX *_mem_save_info_0;
23968         TALLOC_CTX *_mem_save_needed_0;
23969         TALLOC_CTX *_mem_save_count_0;
23970         if (flags & NDR_IN) {
23971                 ZERO_STRUCT(r->out);
23972
23973                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23974                 if (_ptr_servername) {
23975                         NDR_PULL_ALLOC(ndr, r->in.servername);
23976                 } else {
23977                         r->in.servername = NULL;
23978                 }
23979                 if (r->in.servername) {
23980                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23981                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23982                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23983                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23984                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23985                                 return 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));
23986                         }
23987                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23988                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23989                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23990                 }
23991                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23992                 if (_ptr_print_processor_name) {
23993                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23994                 } else {
23995                         r->in.print_processor_name = NULL;
23996                 }
23997                 if (r->in.print_processor_name) {
23998                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23999                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
24000                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
24001                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
24002                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
24003                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.print_processor_name), ndr_get_array_length(ndr, &r->in.print_processor_name));
24004                         }
24005                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
24006                         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));
24007                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
24008                 }
24009                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24010                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24011                 if (_ptr_buffer) {
24012                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24013                 } else {
24014                         r->in.buffer = NULL;
24015                 }
24016                 if (r->in.buffer) {
24017                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24018                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24019                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24020                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24021                 }
24022                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24023                 NDR_PULL_ALLOC(ndr, r->out.needed);
24024                 ZERO_STRUCTP(r->out.needed);
24025                 NDR_PULL_ALLOC(ndr, r->out.count);
24026                 ZERO_STRUCTP(r->out.count);
24027         }
24028         if (flags & NDR_OUT) {
24029                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24030                 if (_ptr_info) {
24031                         NDR_PULL_ALLOC(ndr, r->out.info);
24032                 } else {
24033                         r->out.info = NULL;
24034                 }
24035                 if (r->out.info) {
24036                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24037                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24038                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24039                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24040                 }
24041                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24042                         NDR_PULL_ALLOC(ndr, r->out.needed);
24043                 }
24044                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24045                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24046                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24047                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24048                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24049                         NDR_PULL_ALLOC(ndr, r->out.count);
24050                 }
24051                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24052                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24053                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24054                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24055                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24056         }
24057         return NDR_ERR_SUCCESS;
24058 }
24059
24060 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
24061 {
24062         uint32_t cntr_info_0;
24063         if (flags & NDR_IN) {
24064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24065                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24066         }
24067         if (flags & NDR_OUT) {
24068                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24069                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24070                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24071                 }
24072                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24073                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24074                 }
24075         }
24076         return NDR_ERR_SUCCESS;
24077 }
24078
24079 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
24080 {
24081         uint32_t cntr_info_0;
24082         TALLOC_CTX *_mem_save_info_0;
24083         if (flags & NDR_IN) {
24084                 ZERO_STRUCT(r->out);
24085
24086                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24088         }
24089         if (flags & NDR_OUT) {
24090                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24091                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24092                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24093                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24094                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24095                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24096                 }
24097                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24098                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24099                 }
24100                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24101         }
24102         return NDR_ERR_SUCCESS;
24103 }
24104
24105 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
24106 {
24107         uint32_t cntr_info_2;
24108         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
24109         ndr->depth++;
24110         if (flags & NDR_SET_VALUES) {
24111                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24112         }
24113         if (flags & NDR_IN) {
24114                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
24115                 ndr->depth++;
24116                 ndr_print_ptr(ndr, "servername", r->in.servername);
24117                 ndr->depth++;
24118                 if (r->in.servername) {
24119                         ndr_print_string(ndr, "servername", r->in.servername);
24120                 }
24121                 ndr->depth--;
24122                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
24123                 ndr->depth++;
24124                 if (r->in.print_processor_name) {
24125                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
24126                 }
24127                 ndr->depth--;
24128                 ndr_print_uint32(ndr, "level", r->in.level);
24129                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24130                 ndr->depth++;
24131                 if (r->in.buffer) {
24132                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24133                 }
24134                 ndr->depth--;
24135                 ndr_print_uint32(ndr, "offered", r->in.offered);
24136                 ndr->depth--;
24137         }
24138         if (flags & NDR_OUT) {
24139                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
24140                 ndr->depth++;
24141                 ndr_print_ptr(ndr, "count", r->out.count);
24142                 ndr->depth++;
24143                 ndr_print_uint32(ndr, "count", *r->out.count);
24144                 ndr->depth--;
24145                 ndr_print_ptr(ndr, "info", r->out.info);
24146                 ndr->depth++;
24147                 ndr_print_ptr(ndr, "info", *r->out.info);
24148                 ndr->depth++;
24149                 if (*r->out.info) {
24150                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24151                         ndr->depth++;
24152                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24153                                 char *idx_2=NULL;
24154                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24155                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24156                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24157                                         free(idx_2);
24158                                 }
24159                         }
24160                         ndr->depth--;
24161                 }
24162                 ndr->depth--;
24163                 ndr->depth--;
24164                 ndr_print_ptr(ndr, "needed", r->out.needed);
24165                 ndr->depth++;
24166                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24167                 ndr->depth--;
24168                 ndr_print_WERROR(ndr, "result", r->out.result);
24169                 ndr->depth--;
24170         }
24171         ndr->depth--;
24172 }
24173
24174 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
24175 {
24176         if (flags & NDR_IN) {
24177                 if (r->in.handle == NULL) {
24178                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24179                 }
24180                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24181                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
24182                 if (r->in.data_type) {
24183                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24184                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24185                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24186                         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));
24187                 }
24188                 if (r->in.devmode_ctr == NULL) {
24189                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24190                 }
24191                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24192         }
24193         if (flags & NDR_OUT) {
24194                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24195         }
24196         return NDR_ERR_SUCCESS;
24197 }
24198
24199 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
24200 {
24201         uint32_t _ptr_data_type;
24202         TALLOC_CTX *_mem_save_handle_0;
24203         TALLOC_CTX *_mem_save_data_type_0;
24204         TALLOC_CTX *_mem_save_devmode_ctr_0;
24205         if (flags & NDR_IN) {
24206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24207                         NDR_PULL_ALLOC(ndr, r->in.handle);
24208                 }
24209                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24210                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24211                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24212                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24213                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
24214                 if (_ptr_data_type) {
24215                         NDR_PULL_ALLOC(ndr, r->in.data_type);
24216                 } else {
24217                         r->in.data_type = NULL;
24218                 }
24219                 if (r->in.data_type) {
24220                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24221                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
24222                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
24223                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
24224                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
24225                                 return 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));
24226                         }
24227                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
24228                         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));
24229                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
24230                 }
24231                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24232                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24233                 }
24234                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24235                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24236                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24237                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24238         }
24239         if (flags & NDR_OUT) {
24240                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24241         }
24242         return NDR_ERR_SUCCESS;
24243 }
24244
24245 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
24246 {
24247         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
24248         ndr->depth++;
24249         if (flags & NDR_SET_VALUES) {
24250                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24251         }
24252         if (flags & NDR_IN) {
24253                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
24254                 ndr->depth++;
24255                 ndr_print_ptr(ndr, "handle", r->in.handle);
24256                 ndr->depth++;
24257                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24258                 ndr->depth--;
24259                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
24260                 ndr->depth++;
24261                 if (r->in.data_type) {
24262                         ndr_print_string(ndr, "data_type", r->in.data_type);
24263                 }
24264                 ndr->depth--;
24265                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24266                 ndr->depth++;
24267                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24268                 ndr->depth--;
24269                 ndr->depth--;
24270         }
24271         if (flags & NDR_OUT) {
24272                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
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_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *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.architecture));
24288                 if (r->in.architecture) {
24289                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, 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.architecture, CH_UTF16)));
24292                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24293                 }
24294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24295                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24296                 if (r->in.buffer) {
24297                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24298                 }
24299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
24301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
24302         }
24303         if (flags & NDR_OUT) {
24304                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24305                 if (r->out.info) {
24306                         {
24307                                 struct ndr_push *_ndr_info;
24308                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24309                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24310                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24311                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24312                         }
24313                 }
24314                 if (r->out.needed == NULL) {
24315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24316                 }
24317                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24318                 if (r->out.server_major_version == NULL) {
24319                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24320                 }
24321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24322                 if (r->out.server_minor_version == NULL) {
24323                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24324                 }
24325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24326                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24327         }
24328         return NDR_ERR_SUCCESS;
24329 }
24330
24331 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24332 {
24333         uint32_t _ptr_architecture;
24334         uint32_t _ptr_buffer;
24335         uint32_t _ptr_info;
24336         TALLOC_CTX *_mem_save_handle_0;
24337         TALLOC_CTX *_mem_save_architecture_0;
24338         TALLOC_CTX *_mem_save_buffer_0;
24339         TALLOC_CTX *_mem_save_info_0;
24340         TALLOC_CTX *_mem_save_needed_0;
24341         TALLOC_CTX *_mem_save_server_major_version_0;
24342         TALLOC_CTX *_mem_save_server_minor_version_0;
24343         if (flags & NDR_IN) {
24344                 ZERO_STRUCT(r->out);
24345
24346                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24347                         NDR_PULL_ALLOC(ndr, r->in.handle);
24348                 }
24349                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24350                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24351                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24352                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24353                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24354                 if (_ptr_architecture) {
24355                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24356                 } else {
24357                         r->in.architecture = NULL;
24358                 }
24359                 if (r->in.architecture) {
24360                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24361                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24364                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24365                                 return 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));
24366                         }
24367                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24368                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24370                 }
24371                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24372                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24373                 if (_ptr_buffer) {
24374                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24375                 } else {
24376                         r->in.buffer = NULL;
24377                 }
24378                 if (r->in.buffer) {
24379                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24380                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24381                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24382                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24383                 }
24384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24385                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24387                 NDR_PULL_ALLOC(ndr, r->out.needed);
24388                 ZERO_STRUCTP(r->out.needed);
24389                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24390                 ZERO_STRUCTP(r->out.server_major_version);
24391                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24392                 ZERO_STRUCTP(r->out.server_minor_version);
24393         }
24394         if (flags & NDR_OUT) {
24395                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24396                 if (_ptr_info) {
24397                         NDR_PULL_ALLOC(ndr, r->out.info);
24398                 } else {
24399                         r->out.info = NULL;
24400                 }
24401                 if (r->out.info) {
24402                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24403                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24404                         {
24405                                 struct ndr_pull *_ndr_info;
24406                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24407                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24408                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24409                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24410                         }
24411                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24412                 }
24413                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24414                         NDR_PULL_ALLOC(ndr, r->out.needed);
24415                 }
24416                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24417                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24419                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24420                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24421                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24422                 }
24423                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24424                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24426                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24427                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24428                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24429                 }
24430                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24431                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24433                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24434                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24435         }
24436         return NDR_ERR_SUCCESS;
24437 }
24438
24439 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24440 {
24441         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24442         ndr->depth++;
24443         if (flags & NDR_SET_VALUES) {
24444                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24445         }
24446         if (flags & NDR_IN) {
24447                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24448                 ndr->depth++;
24449                 ndr_print_ptr(ndr, "handle", r->in.handle);
24450                 ndr->depth++;
24451                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24452                 ndr->depth--;
24453                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24454                 ndr->depth++;
24455                 if (r->in.architecture) {
24456                         ndr_print_string(ndr, "architecture", r->in.architecture);
24457                 }
24458                 ndr->depth--;
24459                 ndr_print_uint32(ndr, "level", r->in.level);
24460                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24461                 ndr->depth++;
24462                 if (r->in.buffer) {
24463                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24464                 }
24465                 ndr->depth--;
24466                 ndr_print_uint32(ndr, "offered", r->in.offered);
24467                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24468                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24469                 ndr->depth--;
24470         }
24471         if (flags & NDR_OUT) {
24472                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24473                 ndr->depth++;
24474                 ndr_print_ptr(ndr, "info", r->out.info);
24475                 ndr->depth++;
24476                 if (r->out.info) {
24477                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24478                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24479                 }
24480                 ndr->depth--;
24481                 ndr_print_ptr(ndr, "needed", r->out.needed);
24482                 ndr->depth++;
24483                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24484                 ndr->depth--;
24485                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24486                 ndr->depth++;
24487                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24488                 ndr->depth--;
24489                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24490                 ndr->depth++;
24491                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24492                 ndr->depth--;
24493                 ndr_print_WERROR(ndr, "result", r->out.result);
24494                 ndr->depth--;
24495         }
24496         ndr->depth--;
24497 }
24498
24499 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24500 {
24501         if (flags & NDR_IN) {
24502         }
24503         if (flags & NDR_OUT) {
24504                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24505         }
24506         return NDR_ERR_SUCCESS;
24507 }
24508
24509 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24510 {
24511         if (flags & NDR_IN) {
24512         }
24513         if (flags & NDR_OUT) {
24514                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24515         }
24516         return NDR_ERR_SUCCESS;
24517 }
24518
24519 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24520 {
24521         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24522         ndr->depth++;
24523         if (flags & NDR_SET_VALUES) {
24524                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24525         }
24526         if (flags & NDR_IN) {
24527                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24528                 ndr->depth++;
24529                 ndr->depth--;
24530         }
24531         if (flags & NDR_OUT) {
24532                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24533                 ndr->depth++;
24534                 ndr_print_WERROR(ndr, "result", r->out.result);
24535                 ndr->depth--;
24536         }
24537         ndr->depth--;
24538 }
24539
24540 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24541 {
24542         if (flags & NDR_IN) {
24543         }
24544         if (flags & NDR_OUT) {
24545                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24546         }
24547         return NDR_ERR_SUCCESS;
24548 }
24549
24550 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24551 {
24552         if (flags & NDR_IN) {
24553         }
24554         if (flags & NDR_OUT) {
24555                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24556         }
24557         return NDR_ERR_SUCCESS;
24558 }
24559
24560 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24561 {
24562         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24563         ndr->depth++;
24564         if (flags & NDR_SET_VALUES) {
24565                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24566         }
24567         if (flags & NDR_IN) {
24568                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24569                 ndr->depth++;
24570                 ndr->depth--;
24571         }
24572         if (flags & NDR_OUT) {
24573                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24574                 ndr->depth++;
24575                 ndr_print_WERROR(ndr, "result", r->out.result);
24576                 ndr->depth--;
24577         }
24578         ndr->depth--;
24579 }
24580
24581 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24582 {
24583         if (flags & NDR_IN) {
24584                 if (r->in.handle == NULL) {
24585                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24586                 }
24587                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24588         }
24589         if (flags & NDR_OUT) {
24590                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24591         }
24592         return NDR_ERR_SUCCESS;
24593 }
24594
24595 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24596 {
24597         TALLOC_CTX *_mem_save_handle_0;
24598         if (flags & NDR_IN) {
24599                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24600                         NDR_PULL_ALLOC(ndr, r->in.handle);
24601                 }
24602                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24603                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24604                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24606         }
24607         if (flags & NDR_OUT) {
24608                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24609         }
24610         return NDR_ERR_SUCCESS;
24611 }
24612
24613 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24614 {
24615         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24616         ndr->depth++;
24617         if (flags & NDR_SET_VALUES) {
24618                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24619         }
24620         if (flags & NDR_IN) {
24621                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24622                 ndr->depth++;
24623                 ndr_print_ptr(ndr, "handle", r->in.handle);
24624                 ndr->depth++;
24625                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24626                 ndr->depth--;
24627                 ndr->depth--;
24628         }
24629         if (flags & NDR_OUT) {
24630                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24631                 ndr->depth++;
24632                 ndr_print_WERROR(ndr, "result", r->out.result);
24633                 ndr->depth--;
24634         }
24635         ndr->depth--;
24636 }
24637
24638 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24639 {
24640         if (flags & NDR_IN) {
24641         }
24642         if (flags & NDR_OUT) {
24643                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24644         }
24645         return NDR_ERR_SUCCESS;
24646 }
24647
24648 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24649 {
24650         if (flags & NDR_IN) {
24651         }
24652         if (flags & NDR_OUT) {
24653                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24654         }
24655         return NDR_ERR_SUCCESS;
24656 }
24657
24658 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24659 {
24660         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24661         ndr->depth++;
24662         if (flags & NDR_SET_VALUES) {
24663                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24664         }
24665         if (flags & NDR_IN) {
24666                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24667                 ndr->depth++;
24668                 ndr->depth--;
24669         }
24670         if (flags & NDR_OUT) {
24671                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24672                 ndr->depth++;
24673                 ndr_print_WERROR(ndr, "result", r->out.result);
24674                 ndr->depth--;
24675         }
24676         ndr->depth--;
24677 }
24678
24679 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24680 {
24681         if (flags & NDR_IN) {
24682                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24685                 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));
24686                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24687                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24688                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24689                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24690                 if (r->in.buffer) {
24691                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24692                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24693                 }
24694         }
24695         if (flags & NDR_OUT) {
24696                 if (r->out.handle == NULL) {
24697                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24698                 }
24699                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24700                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24701         }
24702         return NDR_ERR_SUCCESS;
24703 }
24704
24705 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24706 {
24707         uint32_t _ptr_buffer;
24708         TALLOC_CTX *_mem_save_buffer_0;
24709         TALLOC_CTX *_mem_save_handle_0;
24710         if (flags & NDR_IN) {
24711                 ZERO_STRUCT(r->out);
24712
24713                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24714                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24715                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24716                         return 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));
24717                 }
24718                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24719                 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));
24720                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24721                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24722                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24723                 if (r->in.bufsize > 512) {
24724                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24725                 }
24726                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24727                 if (_ptr_buffer) {
24728                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24729                 } else {
24730                         r->in.buffer = NULL;
24731                 }
24732                 if (r->in.buffer) {
24733                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24734                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24735                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24736                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24737                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24738                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24739                 }
24740                 NDR_PULL_ALLOC(ndr, r->out.handle);
24741                 ZERO_STRUCTP(r->out.handle);
24742                 if (r->in.buffer) {
24743                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24744                 }
24745         }
24746         if (flags & NDR_OUT) {
24747                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24748                         NDR_PULL_ALLOC(ndr, r->out.handle);
24749                 }
24750                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24751                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24752                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24753                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24754                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24755         }
24756         return NDR_ERR_SUCCESS;
24757 }
24758
24759 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24760 {
24761         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24762         ndr->depth++;
24763         if (flags & NDR_SET_VALUES) {
24764                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24765         }
24766         if (flags & NDR_IN) {
24767                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24768                 ndr->depth++;
24769                 ndr_print_string(ndr, "server_name", r->in.server_name);
24770                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24771                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24772                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24773                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24774                 ndr->depth++;
24775                 if (r->in.buffer) {
24776                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24777                 }
24778                 ndr->depth--;
24779                 ndr->depth--;
24780         }
24781         if (flags & NDR_OUT) {
24782                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24783                 ndr->depth++;
24784                 ndr_print_ptr(ndr, "handle", r->out.handle);
24785                 ndr->depth++;
24786                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24787                 ndr->depth--;
24788                 ndr_print_WERROR(ndr, "result", r->out.result);
24789                 ndr->depth--;
24790         }
24791         ndr->depth--;
24792 }
24793
24794 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24795 {
24796         if (flags & NDR_IN) {
24797                 if (r->in.handle == NULL) {
24798                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24799                 }
24800                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24801                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24803                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24804                 if (r->in.buffer) {
24805                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24806                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24807                 }
24808         }
24809         if (flags & NDR_OUT) {
24810                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24811         }
24812         return NDR_ERR_SUCCESS;
24813 }
24814
24815 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24816 {
24817         uint32_t _ptr_buffer;
24818         TALLOC_CTX *_mem_save_handle_0;
24819         TALLOC_CTX *_mem_save_buffer_0;
24820         if (flags & NDR_IN) {
24821                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24822                         NDR_PULL_ALLOC(ndr, r->in.handle);
24823                 }
24824                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24825                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24826                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24827                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24828                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24830                 if (r->in.bufsize > 512) {
24831                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24832                 }
24833                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24834                 if (_ptr_buffer) {
24835                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24836                 } else {
24837                         r->in.buffer = NULL;
24838                 }
24839                 if (r->in.buffer) {
24840                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24841                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24842                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24843                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24844                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24845                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24846                 }
24847                 if (r->in.buffer) {
24848                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24849                 }
24850         }
24851         if (flags & NDR_OUT) {
24852                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24853         }
24854         return NDR_ERR_SUCCESS;
24855 }
24856
24857 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24858 {
24859         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24860         ndr->depth++;
24861         if (flags & NDR_SET_VALUES) {
24862                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24863         }
24864         if (flags & NDR_IN) {
24865                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24866                 ndr->depth++;
24867                 ndr_print_ptr(ndr, "handle", r->in.handle);
24868                 ndr->depth++;
24869                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24870                 ndr->depth--;
24871                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24872                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24873                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24874                 ndr->depth++;
24875                 if (r->in.buffer) {
24876                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24877                 }
24878                 ndr->depth--;
24879                 ndr->depth--;
24880         }
24881         if (flags & NDR_OUT) {
24882                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24883                 ndr->depth++;
24884                 ndr_print_WERROR(ndr, "result", r->out.result);
24885                 ndr->depth--;
24886         }
24887         ndr->depth--;
24888 }
24889
24890 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24891 {
24892         if (flags & NDR_IN) {
24893                 if (r->in.handle == NULL) {
24894                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24895                 }
24896                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24897         }
24898         if (flags & NDR_OUT) {
24899                 if (r->out.handle == NULL) {
24900                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24901                 }
24902                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24903                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24904         }
24905         return NDR_ERR_SUCCESS;
24906 }
24907
24908 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24909 {
24910         TALLOC_CTX *_mem_save_handle_0;
24911         if (flags & NDR_IN) {
24912                 ZERO_STRUCT(r->out);
24913
24914                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24915                         NDR_PULL_ALLOC(ndr, r->in.handle);
24916                 }
24917                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24918                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24919                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24920                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24921                 NDR_PULL_ALLOC(ndr, r->out.handle);
24922                 *r->out.handle = *r->in.handle;
24923         }
24924         if (flags & NDR_OUT) {
24925                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24926                         NDR_PULL_ALLOC(ndr, r->out.handle);
24927                 }
24928                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24929                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24930                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24931                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24932                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24933         }
24934         return NDR_ERR_SUCCESS;
24935 }
24936
24937 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24938 {
24939         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24940         ndr->depth++;
24941         if (flags & NDR_SET_VALUES) {
24942                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24943         }
24944         if (flags & NDR_IN) {
24945                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24946                 ndr->depth++;
24947                 ndr_print_ptr(ndr, "handle", r->in.handle);
24948                 ndr->depth++;
24949                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24950                 ndr->depth--;
24951                 ndr->depth--;
24952         }
24953         if (flags & NDR_OUT) {
24954                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24955                 ndr->depth++;
24956                 ndr_print_ptr(ndr, "handle", r->out.handle);
24957                 ndr->depth++;
24958                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24959                 ndr->depth--;
24960                 ndr_print_WERROR(ndr, "result", r->out.result);
24961                 ndr->depth--;
24962         }
24963         ndr->depth--;
24964 }
24965
24966 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24967 {
24968         if (flags & NDR_IN) {
24969         }
24970         if (flags & NDR_OUT) {
24971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24972         }
24973         return NDR_ERR_SUCCESS;
24974 }
24975
24976 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24977 {
24978         if (flags & NDR_IN) {
24979         }
24980         if (flags & NDR_OUT) {
24981                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24982         }
24983         return NDR_ERR_SUCCESS;
24984 }
24985
24986 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24987 {
24988         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24989         ndr->depth++;
24990         if (flags & NDR_SET_VALUES) {
24991                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24992         }
24993         if (flags & NDR_IN) {
24994                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24995                 ndr->depth++;
24996                 ndr->depth--;
24997         }
24998         if (flags & NDR_OUT) {
24999                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
25000                 ndr->depth++;
25001                 ndr_print_WERROR(ndr, "result", r->out.result);
25002                 ndr->depth--;
25003         }
25004         ndr->depth--;
25005 }
25006
25007 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25008 {
25009         if (flags & NDR_IN) {
25010         }
25011         if (flags & NDR_OUT) {
25012                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25013         }
25014         return NDR_ERR_SUCCESS;
25015 }
25016
25017 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25018 {
25019         if (flags & NDR_IN) {
25020         }
25021         if (flags & NDR_OUT) {
25022                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25023         }
25024         return NDR_ERR_SUCCESS;
25025 }
25026
25027 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25028 {
25029         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
25030         ndr->depth++;
25031         if (flags & NDR_SET_VALUES) {
25032                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25033         }
25034         if (flags & NDR_IN) {
25035                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
25036                 ndr->depth++;
25037                 ndr->depth--;
25038         }
25039         if (flags & NDR_OUT) {
25040                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
25041                 ndr->depth++;
25042                 ndr_print_WERROR(ndr, "result", r->out.result);
25043                 ndr->depth--;
25044         }
25045         ndr->depth--;
25046 }
25047
25048 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
25049 {
25050         if (flags & NDR_IN) {
25051         }
25052         if (flags & NDR_OUT) {
25053                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25054         }
25055         return NDR_ERR_SUCCESS;
25056 }
25057
25058 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
25059 {
25060         if (flags & NDR_IN) {
25061         }
25062         if (flags & NDR_OUT) {
25063                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25064         }
25065         return NDR_ERR_SUCCESS;
25066 }
25067
25068 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
25069 {
25070         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
25071         ndr->depth++;
25072         if (flags & NDR_SET_VALUES) {
25073                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25074         }
25075         if (flags & NDR_IN) {
25076                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
25077                 ndr->depth++;
25078                 ndr->depth--;
25079         }
25080         if (flags & NDR_OUT) {
25081                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
25082                 ndr->depth++;
25083                 ndr_print_WERROR(ndr, "result", r->out.result);
25084                 ndr->depth--;
25085         }
25086         ndr->depth--;
25087 }
25088
25089 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
25090 {
25091         if (flags & NDR_IN) {
25092         }
25093         if (flags & NDR_OUT) {
25094                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25095         }
25096         return NDR_ERR_SUCCESS;
25097 }
25098
25099 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
25100 {
25101         if (flags & NDR_IN) {
25102         }
25103         if (flags & NDR_OUT) {
25104                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25105         }
25106         return NDR_ERR_SUCCESS;
25107 }
25108
25109 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
25110 {
25111         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
25112         ndr->depth++;
25113         if (flags & NDR_SET_VALUES) {
25114                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25115         }
25116         if (flags & NDR_IN) {
25117                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
25118                 ndr->depth++;
25119                 ndr->depth--;
25120         }
25121         if (flags & NDR_OUT) {
25122                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
25123                 ndr->depth++;
25124                 ndr_print_WERROR(ndr, "result", r->out.result);
25125                 ndr->depth--;
25126         }
25127         ndr->depth--;
25128 }
25129
25130 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25131 {
25132         if (flags & NDR_IN) {
25133                 if (r->in.handle == NULL) {
25134                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25135                 }
25136                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25137                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25138                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
25139                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
25140                 if (r->in.local_machine) {
25141                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25142                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25143                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25144                         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));
25145                 }
25146                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25147                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
25148                 if (r->in.notify_options) {
25149                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25150                 }
25151         }
25152         if (flags & NDR_OUT) {
25153                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25154         }
25155         return NDR_ERR_SUCCESS;
25156 }
25157
25158 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25159 {
25160         uint32_t _ptr_local_machine;
25161         uint32_t _ptr_notify_options;
25162         TALLOC_CTX *_mem_save_handle_0;
25163         TALLOC_CTX *_mem_save_local_machine_0;
25164         TALLOC_CTX *_mem_save_notify_options_0;
25165         if (flags & NDR_IN) {
25166                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25167                         NDR_PULL_ALLOC(ndr, r->in.handle);
25168                 }
25169                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25170                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25171                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25172                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25173                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
25175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
25176                 if (_ptr_local_machine) {
25177                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
25178                 } else {
25179                         r->in.local_machine = NULL;
25180                 }
25181                 if (r->in.local_machine) {
25182                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
25183                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
25184                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
25185                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
25186                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
25187                                 return 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));
25188                         }
25189                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
25190                         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));
25191                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
25192                 }
25193                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25194                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
25195                 if (_ptr_notify_options) {
25196                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
25197                 } else {
25198                         r->in.notify_options = NULL;
25199                 }
25200                 if (r->in.notify_options) {
25201                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25202                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
25203                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
25205                 }
25206         }
25207         if (flags & NDR_OUT) {
25208                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25209         }
25210         return NDR_ERR_SUCCESS;
25211 }
25212
25213 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25214 {
25215         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25216         ndr->depth++;
25217         if (flags & NDR_SET_VALUES) {
25218                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25219         }
25220         if (flags & NDR_IN) {
25221                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25222                 ndr->depth++;
25223                 ndr_print_ptr(ndr, "handle", r->in.handle);
25224                 ndr->depth++;
25225                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25226                 ndr->depth--;
25227                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25228                 ndr_print_uint32(ndr, "options", r->in.options);
25229                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
25230                 ndr->depth++;
25231                 if (r->in.local_machine) {
25232                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
25233                 }
25234                 ndr->depth--;
25235                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25236                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
25237                 ndr->depth++;
25238                 if (r->in.notify_options) {
25239                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
25240                 }
25241                 ndr->depth--;
25242                 ndr->depth--;
25243         }
25244         if (flags & NDR_OUT) {
25245                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25246                 ndr->depth++;
25247                 ndr_print_WERROR(ndr, "result", r->out.result);
25248                 ndr->depth--;
25249         }
25250         ndr->depth--;
25251 }
25252
25253 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25254 {
25255         if (flags & NDR_IN) {
25256                 if (r->in.handle == NULL) {
25257                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25258                 }
25259                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
25261                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25262                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
25263                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25264                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25265         }
25266         if (flags & NDR_OUT) {
25267                 if (r->out.reply_result == NULL) {
25268                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25269                 }
25270                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
25271                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25272         }
25273         return NDR_ERR_SUCCESS;
25274 }
25275
25276 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
25277 {
25278         TALLOC_CTX *_mem_save_handle_0;
25279         TALLOC_CTX *_mem_save_reply_result_0;
25280         if (flags & NDR_IN) {
25281                 ZERO_STRUCT(r->out);
25282
25283                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25284                         NDR_PULL_ALLOC(ndr, r->in.handle);
25285                 }
25286                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25287                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25288                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25289                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
25291                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25292                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
25293                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25294                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25295                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
25296                 ZERO_STRUCTP(r->out.reply_result);
25297         }
25298         if (flags & NDR_OUT) {
25299                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25300                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
25301                 }
25302                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
25303                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
25304                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
25305                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
25306                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25307         }
25308         return NDR_ERR_SUCCESS;
25309 }
25310
25311 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25312 {
25313         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
25314         ndr->depth++;
25315         if (flags & NDR_SET_VALUES) {
25316                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25317         }
25318         if (flags & NDR_IN) {
25319                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25320                 ndr->depth++;
25321                 ndr_print_ptr(ndr, "handle", r->in.handle);
25322                 ndr->depth++;
25323                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25324                 ndr->depth--;
25325                 ndr_print_uint32(ndr, "color", r->in.color);
25326                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25327                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25328                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25329                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25330                 ndr->depth--;
25331         }
25332         if (flags & NDR_OUT) {
25333                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25334                 ndr->depth++;
25335                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25336                 ndr->depth++;
25337                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25338                 ndr->depth--;
25339                 ndr_print_WERROR(ndr, "result", r->out.result);
25340                 ndr->depth--;
25341         }
25342         ndr->depth--;
25343 }
25344
25345 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25346 {
25347         if (flags & NDR_IN) {
25348                 if (r->in.handle == NULL) {
25349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25350                 }
25351                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25354                 if (r->in.options) {
25355                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25356                 }
25357         }
25358         if (flags & NDR_OUT) {
25359                 if (r->out.info == NULL) {
25360                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25361                 }
25362                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25363                 if (*r->out.info) {
25364                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25365                 }
25366                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25367         }
25368         return NDR_ERR_SUCCESS;
25369 }
25370
25371 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25372 {
25373         uint32_t _ptr_options;
25374         uint32_t _ptr_info;
25375         TALLOC_CTX *_mem_save_handle_0;
25376         TALLOC_CTX *_mem_save_options_0;
25377         TALLOC_CTX *_mem_save_info_0;
25378         TALLOC_CTX *_mem_save_info_1;
25379         if (flags & NDR_IN) {
25380                 ZERO_STRUCT(r->out);
25381
25382                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25383                         NDR_PULL_ALLOC(ndr, r->in.handle);
25384                 }
25385                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25386                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25387                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25388                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25390                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25391                 if (_ptr_options) {
25392                         NDR_PULL_ALLOC(ndr, r->in.options);
25393                 } else {
25394                         r->in.options = NULL;
25395                 }
25396                 if (r->in.options) {
25397                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25398                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25399                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25400                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25401                 }
25402                 NDR_PULL_ALLOC(ndr, r->out.info);
25403                 ZERO_STRUCTP(r->out.info);
25404         }
25405         if (flags & NDR_OUT) {
25406                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25407                         NDR_PULL_ALLOC(ndr, r->out.info);
25408                 }
25409                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25410                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25411                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25412                 if (_ptr_info) {
25413                         NDR_PULL_ALLOC(ndr, *r->out.info);
25414                 } else {
25415                         *r->out.info = NULL;
25416                 }
25417                 if (*r->out.info) {
25418                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25419                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25420                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25421                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25422                 }
25423                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25425         }
25426         return NDR_ERR_SUCCESS;
25427 }
25428
25429 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25430 {
25431         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25432         ndr->depth++;
25433         if (flags & NDR_SET_VALUES) {
25434                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25435         }
25436         if (flags & NDR_IN) {
25437                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25438                 ndr->depth++;
25439                 ndr_print_ptr(ndr, "handle", r->in.handle);
25440                 ndr->depth++;
25441                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25442                 ndr->depth--;
25443                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25444                 ndr_print_ptr(ndr, "options", r->in.options);
25445                 ndr->depth++;
25446                 if (r->in.options) {
25447                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25448                 }
25449                 ndr->depth--;
25450                 ndr->depth--;
25451         }
25452         if (flags & NDR_OUT) {
25453                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25454                 ndr->depth++;
25455                 ndr_print_ptr(ndr, "info", r->out.info);
25456                 ndr->depth++;
25457                 ndr_print_ptr(ndr, "info", *r->out.info);
25458                 ndr->depth++;
25459                 if (*r->out.info) {
25460                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25461                 }
25462                 ndr->depth--;
25463                 ndr->depth--;
25464                 ndr_print_WERROR(ndr, "result", r->out.result);
25465                 ndr->depth--;
25466         }
25467         ndr->depth--;
25468 }
25469
25470 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25471 {
25472         if (flags & NDR_IN) {
25473         }
25474         if (flags & NDR_OUT) {
25475                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25476         }
25477         return NDR_ERR_SUCCESS;
25478 }
25479
25480 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25481 {
25482         if (flags & NDR_IN) {
25483         }
25484         if (flags & NDR_OUT) {
25485                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25486         }
25487         return NDR_ERR_SUCCESS;
25488 }
25489
25490 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25491 {
25492         ndr_print_struct(ndr, name, "spoolss_44");
25493         ndr->depth++;
25494         if (flags & NDR_SET_VALUES) {
25495                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25496         }
25497         if (flags & NDR_IN) {
25498                 ndr_print_struct(ndr, "in", "spoolss_44");
25499                 ndr->depth++;
25500                 ndr->depth--;
25501         }
25502         if (flags & NDR_OUT) {
25503                 ndr_print_struct(ndr, "out", "spoolss_44");
25504                 ndr->depth++;
25505                 ndr_print_WERROR(ndr, "result", r->out.result);
25506                 ndr->depth--;
25507         }
25508         ndr->depth--;
25509 }
25510
25511 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25512 {
25513         if (flags & NDR_IN) {
25514                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25515                 if (r->in.printername) {
25516                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25517                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25518                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25519                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25520                 }
25521                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25522                 if (r->in.datatype) {
25523                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25524                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25525                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25526                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25527                 }
25528                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25529                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25530                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25531                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25532                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25533         }
25534         if (flags & NDR_OUT) {
25535                 if (r->out.handle == NULL) {
25536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25537                 }
25538                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25539                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25540         }
25541         return NDR_ERR_SUCCESS;
25542 }
25543
25544 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25545 {
25546         uint32_t _ptr_printername;
25547         uint32_t _ptr_datatype;
25548         TALLOC_CTX *_mem_save_printername_0;
25549         TALLOC_CTX *_mem_save_datatype_0;
25550         TALLOC_CTX *_mem_save_handle_0;
25551         if (flags & NDR_IN) {
25552                 ZERO_STRUCT(r->out);
25553
25554                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25555                 if (_ptr_printername) {
25556                         NDR_PULL_ALLOC(ndr, r->in.printername);
25557                 } else {
25558                         r->in.printername = NULL;
25559                 }
25560                 if (r->in.printername) {
25561                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25562                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25563                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25564                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25565                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25566                                 return 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));
25567                         }
25568                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25569                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25570                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25571                 }
25572                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25573                 if (_ptr_datatype) {
25574                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25575                 } else {
25576                         r->in.datatype = NULL;
25577                 }
25578                 if (r->in.datatype) {
25579                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25580                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25581                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25582                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25583                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25584                                 return 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));
25585                         }
25586                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25587                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25588                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25589                 }
25590                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25591                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25592                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25593                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25594                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25595                 NDR_PULL_ALLOC(ndr, r->out.handle);
25596                 ZERO_STRUCTP(r->out.handle);
25597         }
25598         if (flags & NDR_OUT) {
25599                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25600                         NDR_PULL_ALLOC(ndr, r->out.handle);
25601                 }
25602                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25603                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25604                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25605                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25606                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25607         }
25608         return NDR_ERR_SUCCESS;
25609 }
25610
25611 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25612 {
25613         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25614         ndr->depth++;
25615         if (flags & NDR_SET_VALUES) {
25616                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25617         }
25618         if (flags & NDR_IN) {
25619                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25620                 ndr->depth++;
25621                 ndr_print_ptr(ndr, "printername", r->in.printername);
25622                 ndr->depth++;
25623                 if (r->in.printername) {
25624                         ndr_print_string(ndr, "printername", r->in.printername);
25625                 }
25626                 ndr->depth--;
25627                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25628                 ndr->depth++;
25629                 if (r->in.datatype) {
25630                         ndr_print_string(ndr, "datatype", r->in.datatype);
25631                 }
25632                 ndr->depth--;
25633                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25634                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25635                 ndr_print_uint32(ndr, "level", r->in.level);
25636                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25637                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25638                 ndr->depth--;
25639         }
25640         if (flags & NDR_OUT) {
25641                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25642                 ndr->depth++;
25643                 ndr_print_ptr(ndr, "handle", r->out.handle);
25644                 ndr->depth++;
25645                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25646                 ndr->depth--;
25647                 ndr_print_WERROR(ndr, "result", r->out.result);
25648                 ndr->depth--;
25649         }
25650         ndr->depth--;
25651 }
25652
25653 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25654 {
25655         if (flags & NDR_IN) {
25656                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25657                 if (r->in.server) {
25658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25659                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25660                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25661                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25662                 }
25663                 if (r->in.info_ctr == NULL) {
25664                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25665                 }
25666                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25667                 if (r->in.devmode_ctr == NULL) {
25668                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25669                 }
25670                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25671                 if (r->in.secdesc_ctr == NULL) {
25672                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25673                 }
25674                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25675                 if (r->in.userlevel_ctr == NULL) {
25676                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25677                 }
25678                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25679         }
25680         if (flags & NDR_OUT) {
25681                 if (r->out.handle == NULL) {
25682                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25683                 }
25684                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25685                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25686         }
25687         return NDR_ERR_SUCCESS;
25688 }
25689
25690 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25691 {
25692         uint32_t _ptr_server;
25693         TALLOC_CTX *_mem_save_server_0;
25694         TALLOC_CTX *_mem_save_info_ctr_0;
25695         TALLOC_CTX *_mem_save_devmode_ctr_0;
25696         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25697         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25698         TALLOC_CTX *_mem_save_handle_0;
25699         if (flags & NDR_IN) {
25700                 ZERO_STRUCT(r->out);
25701
25702                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25703                 if (_ptr_server) {
25704                         NDR_PULL_ALLOC(ndr, r->in.server);
25705                 } else {
25706                         r->in.server = NULL;
25707                 }
25708                 if (r->in.server) {
25709                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25710                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25711                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25712                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25713                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25714                                 return 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));
25715                         }
25716                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25717                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25718                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25719                 }
25720                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25721                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25722                 }
25723                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25724                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25725                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25726                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25727                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25728                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25729                 }
25730                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25731                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25732                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25733                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25734                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25735                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25736                 }
25737                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25738                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25739                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25740                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25741                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25742                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25743                 }
25744                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25745                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25746                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25747                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25748                 NDR_PULL_ALLOC(ndr, r->out.handle);
25749                 ZERO_STRUCTP(r->out.handle);
25750         }
25751         if (flags & NDR_OUT) {
25752                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25753                         NDR_PULL_ALLOC(ndr, r->out.handle);
25754                 }
25755                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25756                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25757                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25758                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25759                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25760         }
25761         return NDR_ERR_SUCCESS;
25762 }
25763
25764 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25765 {
25766         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25767         ndr->depth++;
25768         if (flags & NDR_SET_VALUES) {
25769                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25770         }
25771         if (flags & NDR_IN) {
25772                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25773                 ndr->depth++;
25774                 ndr_print_ptr(ndr, "server", r->in.server);
25775                 ndr->depth++;
25776                 if (r->in.server) {
25777                         ndr_print_string(ndr, "server", r->in.server);
25778                 }
25779                 ndr->depth--;
25780                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25781                 ndr->depth++;
25782                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25783                 ndr->depth--;
25784                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25785                 ndr->depth++;
25786                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25787                 ndr->depth--;
25788                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25789                 ndr->depth++;
25790                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25791                 ndr->depth--;
25792                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25793                 ndr->depth++;
25794                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25795                 ndr->depth--;
25796                 ndr->depth--;
25797         }
25798         if (flags & NDR_OUT) {
25799                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25800                 ndr->depth++;
25801                 ndr_print_ptr(ndr, "handle", r->out.handle);
25802                 ndr->depth++;
25803                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25804                 ndr->depth--;
25805                 ndr_print_WERROR(ndr, "result", r->out.result);
25806                 ndr->depth--;
25807         }
25808         ndr->depth--;
25809 }
25810
25811 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25812 {
25813         if (flags & NDR_IN) {
25814         }
25815         if (flags & NDR_OUT) {
25816                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25817         }
25818         return NDR_ERR_SUCCESS;
25819 }
25820
25821 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25822 {
25823         if (flags & NDR_IN) {
25824         }
25825         if (flags & NDR_OUT) {
25826                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25827         }
25828         return NDR_ERR_SUCCESS;
25829 }
25830
25831 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25832 {
25833         ndr_print_struct(ndr, name, "spoolss_47");
25834         ndr->depth++;
25835         if (flags & NDR_SET_VALUES) {
25836                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25837         }
25838         if (flags & NDR_IN) {
25839                 ndr_print_struct(ndr, "in", "spoolss_47");
25840                 ndr->depth++;
25841                 ndr->depth--;
25842         }
25843         if (flags & NDR_OUT) {
25844                 ndr_print_struct(ndr, "out", "spoolss_47");
25845                 ndr->depth++;
25846                 ndr_print_WERROR(ndr, "result", r->out.result);
25847                 ndr->depth--;
25848         }
25849         ndr->depth--;
25850 }
25851
25852 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25853 {
25854         if (flags & NDR_IN) {
25855                 if (r->in.handle == NULL) {
25856                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25857                 }
25858                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25859                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25862         }
25863         if (flags & NDR_OUT) {
25864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25865                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25866                 if (r->out.value_needed == NULL) {
25867                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25868                 }
25869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25870                 if (r->out.type == NULL) {
25871                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25872                 }
25873                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
25874                 {
25875                         uint32_t _flags_save_uint8 = ndr->flags;
25876                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25877                         if (r->out.data == NULL) {
25878                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25879                         }
25880                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25881                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
25882                         ndr->flags = _flags_save_uint8;
25883                 }
25884                 if (r->out.data_needed == NULL) {
25885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25886                 }
25887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25888                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25889         }
25890         return NDR_ERR_SUCCESS;
25891 }
25892
25893 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25894 {
25895         TALLOC_CTX *_mem_save_handle_0;
25896         TALLOC_CTX *_mem_save_value_needed_0;
25897         TALLOC_CTX *_mem_save_type_0;
25898         TALLOC_CTX *_mem_save_data_needed_0;
25899         if (flags & NDR_IN) {
25900                 ZERO_STRUCT(r->out);
25901
25902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25903                         NDR_PULL_ALLOC(ndr, r->in.handle);
25904                 }
25905                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25906                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25907                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25909                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25910                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25911                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25912                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25913                 ZERO_STRUCTP(r->out.value_needed);
25914                 NDR_PULL_ALLOC(ndr, r->out.type);
25915                 ZERO_STRUCTP(r->out.type);
25916                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
25917                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
25918                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25919                 ZERO_STRUCTP(r->out.data_needed);
25920         }
25921         if (flags & NDR_OUT) {
25922                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25923                 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));
25924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25925                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25926                 }
25927                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25928                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25929                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25932                         NDR_PULL_ALLOC(ndr, r->out.type);
25933                 }
25934                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25935                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
25936                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
25937                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
25938                 {
25939                         uint32_t _flags_save_uint8 = ndr->flags;
25940                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25941                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
25942                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25943                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
25944                         }
25945                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
25946                         ndr->flags = _flags_save_uint8;
25947                 }
25948                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25949                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25950                 }
25951                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25952                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25953                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25954                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25955                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25956                 if (r->out.value_name) {
25957                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25958                 }
25959                 if (r->out.data) {
25960                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
25961                 }
25962         }
25963         return NDR_ERR_SUCCESS;
25964 }
25965
25966 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25967 {
25968         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25969         ndr->depth++;
25970         if (flags & NDR_SET_VALUES) {
25971                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25972         }
25973         if (flags & NDR_IN) {
25974                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25975                 ndr->depth++;
25976                 ndr_print_ptr(ndr, "handle", r->in.handle);
25977                 ndr->depth++;
25978                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25979                 ndr->depth--;
25980                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25981                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25982                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25983                 ndr->depth--;
25984         }
25985         if (flags & NDR_OUT) {
25986                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25987                 ndr->depth++;
25988                 ndr_print_string(ndr, "value_name", r->out.value_name);
25989                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25990                 ndr->depth++;
25991                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25992                 ndr->depth--;
25993                 ndr_print_ptr(ndr, "type", r->out.type);
25994                 ndr->depth++;
25995                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
25996                 ndr->depth--;
25997                 ndr_print_ptr(ndr, "data", r->out.data);
25998                 ndr->depth++;
25999                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
26000                 ndr->depth--;
26001                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
26002                 ndr->depth++;
26003                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
26004                 ndr->depth--;
26005                 ndr_print_WERROR(ndr, "result", r->out.result);
26006                 ndr->depth--;
26007         }
26008         ndr->depth--;
26009 }
26010
26011 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
26012 {
26013         if (flags & NDR_IN) {
26014                 if (r->in.handle == NULL) {
26015                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26016                 }
26017                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26018                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26019                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26020                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26021                 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));
26022         }
26023         if (flags & NDR_OUT) {
26024                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26025         }
26026         return NDR_ERR_SUCCESS;
26027 }
26028
26029 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
26030 {
26031         TALLOC_CTX *_mem_save_handle_0;
26032         if (flags & NDR_IN) {
26033                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26034                         NDR_PULL_ALLOC(ndr, r->in.handle);
26035                 }
26036                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26037                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26038                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26039                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26040                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26041                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26042                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26043                         return 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));
26044                 }
26045                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26046                 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));
26047         }
26048         if (flags & NDR_OUT) {
26049                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26050         }
26051         return NDR_ERR_SUCCESS;
26052 }
26053
26054 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
26055 {
26056         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
26057         ndr->depth++;
26058         if (flags & NDR_SET_VALUES) {
26059                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26060         }
26061         if (flags & NDR_IN) {
26062                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
26063                 ndr->depth++;
26064                 ndr_print_ptr(ndr, "handle", r->in.handle);
26065                 ndr->depth++;
26066                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26067                 ndr->depth--;
26068                 ndr_print_string(ndr, "value_name", r->in.value_name);
26069                 ndr->depth--;
26070         }
26071         if (flags & NDR_OUT) {
26072                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
26073                 ndr->depth++;
26074                 ndr_print_WERROR(ndr, "result", r->out.result);
26075                 ndr->depth--;
26076         }
26077         ndr->depth--;
26078 }
26079
26080 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
26081 {
26082         if (flags & NDR_IN) {
26083         }
26084         if (flags & NDR_OUT) {
26085                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26086         }
26087         return NDR_ERR_SUCCESS;
26088 }
26089
26090 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
26091 {
26092         if (flags & NDR_IN) {
26093         }
26094         if (flags & NDR_OUT) {
26095                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26096         }
26097         return NDR_ERR_SUCCESS;
26098 }
26099
26100 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
26101 {
26102         ndr_print_struct(ndr, name, "spoolss_4a");
26103         ndr->depth++;
26104         if (flags & NDR_SET_VALUES) {
26105                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26106         }
26107         if (flags & NDR_IN) {
26108                 ndr_print_struct(ndr, "in", "spoolss_4a");
26109                 ndr->depth++;
26110                 ndr->depth--;
26111         }
26112         if (flags & NDR_OUT) {
26113                 ndr_print_struct(ndr, "out", "spoolss_4a");
26114                 ndr->depth++;
26115                 ndr_print_WERROR(ndr, "result", r->out.result);
26116                 ndr->depth--;
26117         }
26118         ndr->depth--;
26119 }
26120
26121 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
26122 {
26123         if (flags & NDR_IN) {
26124         }
26125         if (flags & NDR_OUT) {
26126                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26127         }
26128         return NDR_ERR_SUCCESS;
26129 }
26130
26131 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
26132 {
26133         if (flags & NDR_IN) {
26134         }
26135         if (flags & NDR_OUT) {
26136                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26137         }
26138         return NDR_ERR_SUCCESS;
26139 }
26140
26141 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
26142 {
26143         ndr_print_struct(ndr, name, "spoolss_4b");
26144         ndr->depth++;
26145         if (flags & NDR_SET_VALUES) {
26146                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26147         }
26148         if (flags & NDR_IN) {
26149                 ndr_print_struct(ndr, "in", "spoolss_4b");
26150                 ndr->depth++;
26151                 ndr->depth--;
26152         }
26153         if (flags & NDR_OUT) {
26154                 ndr_print_struct(ndr, "out", "spoolss_4b");
26155                 ndr->depth++;
26156                 ndr_print_WERROR(ndr, "result", r->out.result);
26157                 ndr->depth--;
26158         }
26159         ndr->depth--;
26160 }
26161
26162 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
26163 {
26164         if (flags & NDR_IN) {
26165         }
26166         if (flags & NDR_OUT) {
26167                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26168         }
26169         return NDR_ERR_SUCCESS;
26170 }
26171
26172 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
26173 {
26174         if (flags & NDR_IN) {
26175         }
26176         if (flags & NDR_OUT) {
26177                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26178         }
26179         return NDR_ERR_SUCCESS;
26180 }
26181
26182 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
26183 {
26184         ndr_print_struct(ndr, name, "spoolss_4c");
26185         ndr->depth++;
26186         if (flags & NDR_SET_VALUES) {
26187                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26188         }
26189         if (flags & NDR_IN) {
26190                 ndr_print_struct(ndr, "in", "spoolss_4c");
26191                 ndr->depth++;
26192                 ndr->depth--;
26193         }
26194         if (flags & NDR_OUT) {
26195                 ndr_print_struct(ndr, "out", "spoolss_4c");
26196                 ndr->depth++;
26197                 ndr_print_WERROR(ndr, "result", r->out.result);
26198                 ndr->depth--;
26199         }
26200         ndr->depth--;
26201 }
26202
26203 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
26204 {
26205         if (flags & NDR_IN) {
26206                 if (r->in.handle == NULL) {
26207                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26208                 }
26209                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26210                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26211                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26212                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26213                 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));
26214                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26215                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26216                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26217                 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));
26218                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26219                 if (r->in.buffer == NULL) {
26220                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26221                 }
26222                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26223                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
26224                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26225         }
26226         if (flags & NDR_OUT) {
26227                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26228         }
26229         return NDR_ERR_SUCCESS;
26230 }
26231
26232 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
26233 {
26234         TALLOC_CTX *_mem_save_handle_0;
26235         if (flags & NDR_IN) {
26236                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26237                         NDR_PULL_ALLOC(ndr, r->in.handle);
26238                 }
26239                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26240                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26241                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26242                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26243                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26244                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26245                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26246                         return 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));
26247                 }
26248                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26249                 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));
26250                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26251                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26252                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26253                         return 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));
26254                 }
26255                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26256                 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));
26257                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26258                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26260                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26261                 }
26262                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26264                 if (r->in.buffer) {
26265                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
26266                 }
26267         }
26268         if (flags & NDR_OUT) {
26269                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26270         }
26271         return NDR_ERR_SUCCESS;
26272 }
26273
26274 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
26275 {
26276         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
26277         ndr->depth++;
26278         if (flags & NDR_SET_VALUES) {
26279                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26280         }
26281         if (flags & NDR_IN) {
26282                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
26283                 ndr->depth++;
26284                 ndr_print_ptr(ndr, "handle", r->in.handle);
26285                 ndr->depth++;
26286                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26287                 ndr->depth--;
26288                 ndr_print_string(ndr, "key_name", r->in.key_name);
26289                 ndr_print_string(ndr, "value_name", r->in.value_name);
26290                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26291                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26292                 ndr->depth++;
26293                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
26294                 ndr->depth--;
26295                 ndr_print_uint32(ndr, "offered", r->in.offered);
26296                 ndr->depth--;
26297         }
26298         if (flags & NDR_OUT) {
26299                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
26300                 ndr->depth++;
26301                 ndr_print_WERROR(ndr, "result", r->out.result);
26302                 ndr->depth--;
26303         }
26304         ndr->depth--;
26305 }
26306
26307 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
26308 {
26309         if (flags & NDR_IN) {
26310                 if (r->in.handle == NULL) {
26311                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26312                 }
26313                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26314                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26316                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26317                 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));
26318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26321                 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));
26322                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26323         }
26324         if (flags & NDR_OUT) {
26325                 if (r->out.type == NULL) {
26326                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26327                 }
26328                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26329                 if (r->out.buffer == NULL) {
26330                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26331                 }
26332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26333                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26334                 if (r->out.needed == NULL) {
26335                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26336                 }
26337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26338                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26339         }
26340         return NDR_ERR_SUCCESS;
26341 }
26342
26343 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26344 {
26345         TALLOC_CTX *_mem_save_handle_0;
26346         TALLOC_CTX *_mem_save_type_0;
26347         TALLOC_CTX *_mem_save_needed_0;
26348         if (flags & NDR_IN) {
26349                 ZERO_STRUCT(r->out);
26350
26351                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26352                         NDR_PULL_ALLOC(ndr, r->in.handle);
26353                 }
26354                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26355                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26356                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26357                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26358                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26359                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26360                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26361                         return 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));
26362                 }
26363                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26364                 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));
26365                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26366                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26367                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26368                         return 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));
26369                 }
26370                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26371                 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));
26372                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26373                 NDR_PULL_ALLOC(ndr, r->out.type);
26374                 ZERO_STRUCTP(r->out.type);
26375                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26376                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26377                 NDR_PULL_ALLOC(ndr, r->out.needed);
26378                 ZERO_STRUCTP(r->out.needed);
26379         }
26380         if (flags & NDR_OUT) {
26381                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26382                         NDR_PULL_ALLOC(ndr, r->out.type);
26383                 }
26384                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26385                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26386                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26387                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26388                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26389                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26390                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26391                 }
26392                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26393                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26394                         NDR_PULL_ALLOC(ndr, r->out.needed);
26395                 }
26396                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26397                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26398                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26399                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26400                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26401                 if (r->out.buffer) {
26402                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26403                 }
26404         }
26405         return NDR_ERR_SUCCESS;
26406 }
26407
26408 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26409 {
26410         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26411         ndr->depth++;
26412         if (flags & NDR_SET_VALUES) {
26413                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26414         }
26415         if (flags & NDR_IN) {
26416                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26417                 ndr->depth++;
26418                 ndr_print_ptr(ndr, "handle", r->in.handle);
26419                 ndr->depth++;
26420                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26421                 ndr->depth--;
26422                 ndr_print_string(ndr, "key_name", r->in.key_name);
26423                 ndr_print_string(ndr, "value_name", r->in.value_name);
26424                 ndr_print_uint32(ndr, "offered", r->in.offered);
26425                 ndr->depth--;
26426         }
26427         if (flags & NDR_OUT) {
26428                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26429                 ndr->depth++;
26430                 ndr_print_ptr(ndr, "type", r->out.type);
26431                 ndr->depth++;
26432                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26433                 ndr->depth--;
26434                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26435                 ndr->depth++;
26436                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26437                 ndr->depth--;
26438                 ndr_print_ptr(ndr, "needed", r->out.needed);
26439                 ndr->depth++;
26440                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26441                 ndr->depth--;
26442                 ndr_print_WERROR(ndr, "result", r->out.result);
26443                 ndr->depth--;
26444         }
26445         ndr->depth--;
26446 }
26447
26448 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
26449 {
26450         if (flags & NDR_IN) {
26451                 if (r->in.handle == NULL) {
26452                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26453                 }
26454                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26455                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26456                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26457                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26458                 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));
26459                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26460         }
26461         if (flags & NDR_OUT) {
26462                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26463                 if (r->out.needed == NULL) {
26464                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26465                 }
26466                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26467                 if (r->out.count == NULL) {
26468                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26469                 }
26470                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26471                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26472         }
26473         return NDR_ERR_SUCCESS;
26474 }
26475
26476 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
26477 {
26478         TALLOC_CTX *_mem_save_handle_0;
26479         TALLOC_CTX *_mem_save_needed_0;
26480         TALLOC_CTX *_mem_save_count_0;
26481         if (flags & NDR_IN) {
26482                 ZERO_STRUCT(r->out);
26483
26484                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26485                         NDR_PULL_ALLOC(ndr, r->in.handle);
26486                 }
26487                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26488                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26489                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26491                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26492                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26493                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26494                         return 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));
26495                 }
26496                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26497                 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));
26498                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26499                 NDR_PULL_ALLOC(ndr, r->out.needed);
26500                 ZERO_STRUCTP(r->out.needed);
26501                 NDR_PULL_ALLOC(ndr, r->out.count);
26502                 ZERO_STRUCTP(r->out.count);
26503         }
26504         if (flags & NDR_OUT) {
26505                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
26506                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26507                         NDR_PULL_ALLOC(ndr, r->out.needed);
26508                 }
26509                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26510                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26511                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26512                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26513                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26514                         NDR_PULL_ALLOC(ndr, r->out.count);
26515                 }
26516                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26517                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26518                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26519                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26520                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26521         }
26522         return NDR_ERR_SUCCESS;
26523 }
26524
26525 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
26526 {
26527         uint32_t cntr_info_0;
26528         if (flags & NDR_IN) {
26529                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26530         }
26531         if (flags & NDR_OUT) {
26532                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26533                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26534                 }
26535                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26536                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26537                 }
26538         }
26539         return NDR_ERR_SUCCESS;
26540 }
26541
26542 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
26543 {
26544         uint32_t cntr_info_0;
26545         TALLOC_CTX *_mem_save_info_0;
26546         if (flags & NDR_IN) {
26547                 ZERO_STRUCT(r->out);
26548
26549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26550         }
26551         if (flags & NDR_OUT) {
26552                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26553                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26554                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26555                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26556                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26557                 }
26558                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26559                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26560                 }
26561                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26562         }
26563         return NDR_ERR_SUCCESS;
26564 }
26565
26566 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26567 {
26568         uint32_t cntr_info_2;
26569         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26570         ndr->depth++;
26571         if (flags & NDR_SET_VALUES) {
26572                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26573         }
26574         if (flags & NDR_IN) {
26575                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26576                 ndr->depth++;
26577                 ndr_print_ptr(ndr, "handle", r->in.handle);
26578                 ndr->depth++;
26579                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26580                 ndr->depth--;
26581                 ndr_print_string(ndr, "key_name", r->in.key_name);
26582                 ndr_print_uint32(ndr, "offered", r->in.offered);
26583                 ndr->depth--;
26584         }
26585         if (flags & NDR_OUT) {
26586                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26587                 ndr->depth++;
26588                 ndr_print_ptr(ndr, "count", r->out.count);
26589                 ndr->depth++;
26590                 ndr_print_uint32(ndr, "count", *r->out.count);
26591                 ndr->depth--;
26592                 ndr_print_ptr(ndr, "info", r->out.info);
26593                 ndr->depth++;
26594                 ndr_print_ptr(ndr, "info", *r->out.info);
26595                 ndr->depth++;
26596                 if (*r->out.info) {
26597                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26598                         ndr->depth++;
26599                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26600                                 char *idx_2=NULL;
26601                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26602                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
26603                                         free(idx_2);
26604                                 }
26605                         }
26606                         ndr->depth--;
26607                 }
26608                 ndr->depth--;
26609                 ndr->depth--;
26610                 ndr_print_ptr(ndr, "needed", r->out.needed);
26611                 ndr->depth++;
26612                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26613                 ndr->depth--;
26614                 ndr_print_WERROR(ndr, "result", r->out.result);
26615                 ndr->depth--;
26616         }
26617         ndr->depth--;
26618 }
26619
26620 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26621 {
26622         uint32_t cntr_key_buffer_1;
26623         if (flags & NDR_IN) {
26624                 if (r->in.handle == NULL) {
26625                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26626                 }
26627                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26630                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26631                 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));
26632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26633         }
26634         if (flags & NDR_OUT) {
26635                 if (r->out.key_buffer == NULL) {
26636                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26637                 }
26638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered / 2));
26639                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.offered / 2; cntr_key_buffer_1++) {
26640                         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->out.key_buffer[cntr_key_buffer_1]));
26641                 }
26642                 if (r->out.needed == NULL) {
26643                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26644                 }
26645                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26646                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26647         }
26648         return NDR_ERR_SUCCESS;
26649 }
26650
26651 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26652 {
26653         uint32_t cntr_key_buffer_1;
26654         TALLOC_CTX *_mem_save_handle_0;
26655         TALLOC_CTX *_mem_save_key_buffer_1;
26656         TALLOC_CTX *_mem_save_needed_0;
26657         if (flags & NDR_IN) {
26658                 ZERO_STRUCT(r->out);
26659
26660                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26661                         NDR_PULL_ALLOC(ndr, r->in.handle);
26662                 }
26663                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26664                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26665                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26666                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26667                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26668                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26669                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26670                         return 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));
26671                 }
26672                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26673                 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));
26674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26675                 NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, r->in.offered / 2);
26676                 memset(r->out.key_buffer, 0, (r->in.offered / 2) * sizeof(*r->out.key_buffer));
26677                 NDR_PULL_ALLOC(ndr, r->out.needed);
26678                 ZERO_STRUCTP(r->out.needed);
26679         }
26680         if (flags & NDR_OUT) {
26681                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.key_buffer));
26682                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26683                         NDR_PULL_ALLOC_N(ndr, r->out.key_buffer, ndr_get_array_size(ndr, &r->out.key_buffer));
26684                 }
26685                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26686                 NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, 0);
26687                 for (cntr_key_buffer_1 = 0; cntr_key_buffer_1 < r->in.offered / 2; cntr_key_buffer_1++) {
26688                         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->out.key_buffer[cntr_key_buffer_1]));
26689                 }
26690                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26691                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26692                         NDR_PULL_ALLOC(ndr, r->out.needed);
26693                 }
26694                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26695                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26697                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26698                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26699                 if (r->out.key_buffer) {
26700                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.key_buffer, r->in.offered / 2));
26701                 }
26702         }
26703         return NDR_ERR_SUCCESS;
26704 }
26705
26706 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26707 {
26708         uint32_t cntr_key_buffer_1;
26709         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26710         ndr->depth++;
26711         if (flags & NDR_SET_VALUES) {
26712                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26713         }
26714         if (flags & NDR_IN) {
26715                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26716                 ndr->depth++;
26717                 ndr_print_ptr(ndr, "handle", r->in.handle);
26718                 ndr->depth++;
26719                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26720                 ndr->depth--;
26721                 ndr_print_string(ndr, "key_name", r->in.key_name);
26722                 ndr_print_uint32(ndr, "offered", r->in.offered);
26723                 ndr->depth--;
26724         }
26725         if (flags & NDR_OUT) {
26726                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26727                 ndr->depth++;
26728                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26729                 ndr->depth++;
26730                 ndr->print(ndr, "%s: ARRAY(%d)", "key_buffer", (int)r->in.offered / 2);
26731                 ndr->depth++;
26732                 for (cntr_key_buffer_1=0;cntr_key_buffer_1<r->in.offered / 2;cntr_key_buffer_1++) {
26733                         char *idx_1=NULL;
26734                         if (asprintf(&idx_1, "[%d]", cntr_key_buffer_1) != -1) {
26735                                 ndr_print_uint16(ndr, "key_buffer", r->out.key_buffer[cntr_key_buffer_1]);
26736                                 free(idx_1);
26737                         }
26738                 }
26739                 ndr->depth--;
26740                 ndr->depth--;
26741                 ndr_print_ptr(ndr, "needed", r->out.needed);
26742                 ndr->depth++;
26743                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26744                 ndr->depth--;
26745                 ndr_print_WERROR(ndr, "result", r->out.result);
26746                 ndr->depth--;
26747         }
26748         ndr->depth--;
26749 }
26750
26751 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26752 {
26753         if (flags & NDR_IN) {
26754                 if (r->in.handle == NULL) {
26755                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26756                 }
26757                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26761                 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));
26762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26763                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26765                 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));
26766         }
26767         if (flags & NDR_OUT) {
26768                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26769         }
26770         return NDR_ERR_SUCCESS;
26771 }
26772
26773 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26774 {
26775         TALLOC_CTX *_mem_save_handle_0;
26776         if (flags & NDR_IN) {
26777                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26778                         NDR_PULL_ALLOC(ndr, r->in.handle);
26779                 }
26780                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26781                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26782                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26783                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26784                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26785                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26786                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26787                         return 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));
26788                 }
26789                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26790                 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));
26791                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26792                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26793                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26794                         return 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));
26795                 }
26796                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26797                 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));
26798         }
26799         if (flags & NDR_OUT) {
26800                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26801         }
26802         return NDR_ERR_SUCCESS;
26803 }
26804
26805 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26806 {
26807         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26808         ndr->depth++;
26809         if (flags & NDR_SET_VALUES) {
26810                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26811         }
26812         if (flags & NDR_IN) {
26813                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26814                 ndr->depth++;
26815                 ndr_print_ptr(ndr, "handle", r->in.handle);
26816                 ndr->depth++;
26817                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26818                 ndr->depth--;
26819                 ndr_print_string(ndr, "key_name", r->in.key_name);
26820                 ndr_print_string(ndr, "value_name", r->in.value_name);
26821                 ndr->depth--;
26822         }
26823         if (flags & NDR_OUT) {
26824                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26825                 ndr->depth++;
26826                 ndr_print_WERROR(ndr, "result", r->out.result);
26827                 ndr->depth--;
26828         }
26829         ndr->depth--;
26830 }
26831
26832 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26833 {
26834         if (flags & NDR_IN) {
26835                 if (r->in.handle == NULL) {
26836                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26837                 }
26838                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26840                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26841                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26842                 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));
26843         }
26844         if (flags & NDR_OUT) {
26845                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26846         }
26847         return NDR_ERR_SUCCESS;
26848 }
26849
26850 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26851 {
26852         TALLOC_CTX *_mem_save_handle_0;
26853         if (flags & NDR_IN) {
26854                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26855                         NDR_PULL_ALLOC(ndr, r->in.handle);
26856                 }
26857                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26858                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26859                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26860                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26861                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26862                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26863                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26864                         return 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));
26865                 }
26866                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26867                 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));
26868         }
26869         if (flags & NDR_OUT) {
26870                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26871         }
26872         return NDR_ERR_SUCCESS;
26873 }
26874
26875 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26876 {
26877         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26878         ndr->depth++;
26879         if (flags & NDR_SET_VALUES) {
26880                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26881         }
26882         if (flags & NDR_IN) {
26883                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26884                 ndr->depth++;
26885                 ndr_print_ptr(ndr, "handle", r->in.handle);
26886                 ndr->depth++;
26887                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26888                 ndr->depth--;
26889                 ndr_print_string(ndr, "key_name", r->in.key_name);
26890                 ndr->depth--;
26891         }
26892         if (flags & NDR_OUT) {
26893                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26894                 ndr->depth++;
26895                 ndr_print_WERROR(ndr, "result", r->out.result);
26896                 ndr->depth--;
26897         }
26898         ndr->depth--;
26899 }
26900
26901 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26902 {
26903         if (flags & NDR_IN) {
26904         }
26905         if (flags & NDR_OUT) {
26906                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26907         }
26908         return NDR_ERR_SUCCESS;
26909 }
26910
26911 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26912 {
26913         if (flags & NDR_IN) {
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_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26922 {
26923         ndr_print_struct(ndr, name, "spoolss_53");
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_53");
26930                 ndr->depth++;
26931                 ndr->depth--;
26932         }
26933         if (flags & NDR_OUT) {
26934                 ndr_print_struct(ndr, "out", "spoolss_53");
26935                 ndr->depth++;
26936                 ndr_print_WERROR(ndr, "result", r->out.result);
26937                 ndr->depth--;
26938         }
26939         ndr->depth--;
26940 }
26941
26942 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26943 {
26944         if (flags & NDR_IN) {
26945                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26946                 if (r->in.server) {
26947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26948                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26949                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26950                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26951                 }
26952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26953                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26955                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26957                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26958                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26959                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26960                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26961                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26962         }
26963         if (flags & NDR_OUT) {
26964                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26965         }
26966         return NDR_ERR_SUCCESS;
26967 }
26968
26969 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26970 {
26971         uint32_t _ptr_server;
26972         TALLOC_CTX *_mem_save_server_0;
26973         if (flags & NDR_IN) {
26974                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26975                 if (_ptr_server) {
26976                         NDR_PULL_ALLOC(ndr, r->in.server);
26977                 } else {
26978                         r->in.server = NULL;
26979                 }
26980                 if (r->in.server) {
26981                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26982                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26983                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26984                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26985                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26986                                 return 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));
26987                         }
26988                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26989                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26990                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26991                 }
26992                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26993                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26994                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26995                         return 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));
26996                 }
26997                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26998                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26999                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
27000                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
27001                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
27002                         return 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));
27003                 }
27004                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
27005                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
27006                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
27007                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
27008         }
27009         if (flags & NDR_OUT) {
27010                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27011         }
27012         return NDR_ERR_SUCCESS;
27013 }
27014
27015 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27016 {
27017         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
27018         ndr->depth++;
27019         if (flags & NDR_SET_VALUES) {
27020                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27021         }
27022         if (flags & NDR_IN) {
27023                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
27024                 ndr->depth++;
27025                 ndr_print_ptr(ndr, "server", r->in.server);
27026                 ndr->depth++;
27027                 if (r->in.server) {
27028                         ndr_print_string(ndr, "server", r->in.server);
27029                 }
27030                 ndr->depth--;
27031                 ndr_print_string(ndr, "architecture", r->in.architecture);
27032                 ndr_print_string(ndr, "driver", r->in.driver);
27033                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
27034                 ndr_print_uint32(ndr, "version", r->in.version);
27035                 ndr->depth--;
27036         }
27037         if (flags & NDR_OUT) {
27038                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
27039                 ndr->depth++;
27040                 ndr_print_WERROR(ndr, "result", r->out.result);
27041                 ndr->depth--;
27042         }
27043         ndr->depth--;
27044 }
27045
27046 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
27047 {
27048         if (flags & NDR_IN) {
27049         }
27050         if (flags & NDR_OUT) {
27051                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27052         }
27053         return NDR_ERR_SUCCESS;
27054 }
27055
27056 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
27057 {
27058         if (flags & NDR_IN) {
27059         }
27060         if (flags & NDR_OUT) {
27061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27062         }
27063         return NDR_ERR_SUCCESS;
27064 }
27065
27066 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
27067 {
27068         ndr_print_struct(ndr, name, "spoolss_55");
27069         ndr->depth++;
27070         if (flags & NDR_SET_VALUES) {
27071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27072         }
27073         if (flags & NDR_IN) {
27074                 ndr_print_struct(ndr, "in", "spoolss_55");
27075                 ndr->depth++;
27076                 ndr->depth--;
27077         }
27078         if (flags & NDR_OUT) {
27079                 ndr_print_struct(ndr, "out", "spoolss_55");
27080                 ndr->depth++;
27081                 ndr_print_WERROR(ndr, "result", r->out.result);
27082                 ndr->depth--;
27083         }
27084         ndr->depth--;
27085 }
27086
27087 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
27088 {
27089         if (flags & NDR_IN) {
27090         }
27091         if (flags & NDR_OUT) {
27092                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27093         }
27094         return NDR_ERR_SUCCESS;
27095 }
27096
27097 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
27098 {
27099         if (flags & NDR_IN) {
27100         }
27101         if (flags & NDR_OUT) {
27102                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27103         }
27104         return NDR_ERR_SUCCESS;
27105 }
27106
27107 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
27108 {
27109         ndr_print_struct(ndr, name, "spoolss_56");
27110         ndr->depth++;
27111         if (flags & NDR_SET_VALUES) {
27112                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27113         }
27114         if (flags & NDR_IN) {
27115                 ndr_print_struct(ndr, "in", "spoolss_56");
27116                 ndr->depth++;
27117                 ndr->depth--;
27118         }
27119         if (flags & NDR_OUT) {
27120                 ndr_print_struct(ndr, "out", "spoolss_56");
27121                 ndr->depth++;
27122                 ndr_print_WERROR(ndr, "result", r->out.result);
27123                 ndr->depth--;
27124         }
27125         ndr->depth--;
27126 }
27127
27128 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
27129 {
27130         if (flags & NDR_IN) {
27131         }
27132         if (flags & NDR_OUT) {
27133                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27134         }
27135         return NDR_ERR_SUCCESS;
27136 }
27137
27138 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
27139 {
27140         if (flags & NDR_IN) {
27141         }
27142         if (flags & NDR_OUT) {
27143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27144         }
27145         return NDR_ERR_SUCCESS;
27146 }
27147
27148 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
27149 {
27150         ndr_print_struct(ndr, name, "spoolss_57");
27151         ndr->depth++;
27152         if (flags & NDR_SET_VALUES) {
27153                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27154         }
27155         if (flags & NDR_IN) {
27156                 ndr_print_struct(ndr, "in", "spoolss_57");
27157                 ndr->depth++;
27158                 ndr->depth--;
27159         }
27160         if (flags & NDR_OUT) {
27161                 ndr_print_struct(ndr, "out", "spoolss_57");
27162                 ndr->depth++;
27163                 ndr_print_WERROR(ndr, "result", r->out.result);
27164                 ndr->depth--;
27165         }
27166         ndr->depth--;
27167 }
27168
27169 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
27170 {
27171         if (flags & NDR_IN) {
27172                 if (r->in.handle == NULL) {
27173                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27174                 }
27175                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27177                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27178                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27179                 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));
27180                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
27181                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
27182                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27183                 if (r->in.status_code == NULL) {
27184                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27185                 }
27186                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
27187         }
27188         if (flags & NDR_OUT) {
27189                 if (r->out.out_data == NULL) {
27190                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27191                 }
27192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27193                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
27194                 if (r->out.needed == NULL) {
27195                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27196                 }
27197                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27198                 if (r->out.status_code == NULL) {
27199                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27200                 }
27201                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
27202                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27203         }
27204         return NDR_ERR_SUCCESS;
27205 }
27206
27207 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
27208 {
27209         TALLOC_CTX *_mem_save_handle_0;
27210         TALLOC_CTX *_mem_save_needed_0;
27211         TALLOC_CTX *_mem_save_status_code_0;
27212         if (flags & NDR_IN) {
27213                 ZERO_STRUCT(r->out);
27214
27215                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27216                         NDR_PULL_ALLOC(ndr, r->in.handle);
27217                 }
27218                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27219                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27220                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27221                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27222                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
27223                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
27224                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
27225                         return 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));
27226                 }
27227                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
27228                 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));
27229                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
27230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
27231                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
27232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27233                         NDR_PULL_ALLOC(ndr, r->in.status_code);
27234                 }
27235                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27236                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
27237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
27238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27239                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
27240                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
27241                 NDR_PULL_ALLOC(ndr, r->out.needed);
27242                 ZERO_STRUCTP(r->out.needed);
27243                 NDR_PULL_ALLOC(ndr, r->out.status_code);
27244                 *r->out.status_code = *r->in.status_code;
27245         }
27246         if (flags & NDR_OUT) {
27247                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
27248                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27249                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
27250                 }
27251                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
27252                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27253                         NDR_PULL_ALLOC(ndr, r->out.needed);
27254                 }
27255                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27256                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27257                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27258                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27259                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27260                         NDR_PULL_ALLOC(ndr, r->out.status_code);
27261                 }
27262                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27263                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
27264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
27265                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27266                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27267                 if (r->out.out_data) {
27268                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
27269                 }
27270         }
27271         return NDR_ERR_SUCCESS;
27272 }
27273
27274 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
27275 {
27276         ndr_print_struct(ndr, name, "spoolss_XcvData");
27277         ndr->depth++;
27278         if (flags & NDR_SET_VALUES) {
27279                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27280         }
27281         if (flags & NDR_IN) {
27282                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
27283                 ndr->depth++;
27284                 ndr_print_ptr(ndr, "handle", r->in.handle);
27285                 ndr->depth++;
27286                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27287                 ndr->depth--;
27288                 ndr_print_string(ndr, "function_name", r->in.function_name);
27289                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
27290                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
27291                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
27292                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
27293                 ndr->depth++;
27294                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
27295                 ndr->depth--;
27296                 ndr->depth--;
27297         }
27298         if (flags & NDR_OUT) {
27299                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
27300                 ndr->depth++;
27301                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
27302                 ndr->depth++;
27303                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
27304                 ndr->depth--;
27305                 ndr_print_ptr(ndr, "needed", r->out.needed);
27306                 ndr->depth++;
27307                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27308                 ndr->depth--;
27309                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
27310                 ndr->depth++;
27311                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
27312                 ndr->depth--;
27313                 ndr_print_WERROR(ndr, "result", r->out.result);
27314                 ndr->depth--;
27315         }
27316         ndr->depth--;
27317 }
27318
27319 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
27320 {
27321         if (flags & NDR_IN) {
27322                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
27323                 if (r->in.servername) {
27324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27325                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27326                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27327                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27328                 }
27329                 if (r->in.info_ctr == NULL) {
27330                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27331                 }
27332                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27333                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
27334         }
27335         if (flags & NDR_OUT) {
27336                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27337         }
27338         return NDR_ERR_SUCCESS;
27339 }
27340
27341 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
27342 {
27343         uint32_t _ptr_servername;
27344         TALLOC_CTX *_mem_save_servername_0;
27345         TALLOC_CTX *_mem_save_info_ctr_0;
27346         if (flags & NDR_IN) {
27347                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
27348                 if (_ptr_servername) {
27349                         NDR_PULL_ALLOC(ndr, r->in.servername);
27350                 } else {
27351                         r->in.servername = NULL;
27352                 }
27353                 if (r->in.servername) {
27354                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27355                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
27356                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
27357                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
27358                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
27359                                 return 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));
27360                         }
27361                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
27362                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
27363                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
27364                 }
27365                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27366                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27367                 }
27368                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27369                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27370                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27371                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27372                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27373         }
27374         if (flags & NDR_OUT) {
27375                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27376         }
27377         return NDR_ERR_SUCCESS;
27378 }
27379
27380 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27381 {
27382         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27383         ndr->depth++;
27384         if (flags & NDR_SET_VALUES) {
27385                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27386         }
27387         if (flags & NDR_IN) {
27388                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27389                 ndr->depth++;
27390                 ndr_print_ptr(ndr, "servername", r->in.servername);
27391                 ndr->depth++;
27392                 if (r->in.servername) {
27393                         ndr_print_string(ndr, "servername", r->in.servername);
27394                 }
27395                 ndr->depth--;
27396                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27397                 ndr->depth++;
27398                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27399                 ndr->depth--;
27400                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
27401                 ndr->depth--;
27402         }
27403         if (flags & NDR_OUT) {
27404                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
27405                 ndr->depth++;
27406                 ndr_print_WERROR(ndr, "result", r->out.result);
27407                 ndr->depth--;
27408         }
27409         ndr->depth--;
27410 }
27411
27412 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
27413 {
27414         if (flags & NDR_IN) {
27415         }
27416         if (flags & NDR_OUT) {
27417                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27418         }
27419         return NDR_ERR_SUCCESS;
27420 }
27421
27422 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27423 {
27424         if (flags & NDR_IN) {
27425         }
27426         if (flags & NDR_OUT) {
27427                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27428         }
27429         return NDR_ERR_SUCCESS;
27430 }
27431
27432 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27433 {
27434         ndr_print_struct(ndr, name, "spoolss_5a");
27435         ndr->depth++;
27436         if (flags & NDR_SET_VALUES) {
27437                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27438         }
27439         if (flags & NDR_IN) {
27440                 ndr_print_struct(ndr, "in", "spoolss_5a");
27441                 ndr->depth++;
27442                 ndr->depth--;
27443         }
27444         if (flags & NDR_OUT) {
27445                 ndr_print_struct(ndr, "out", "spoolss_5a");
27446                 ndr->depth++;
27447                 ndr_print_WERROR(ndr, "result", r->out.result);
27448                 ndr->depth--;
27449         }
27450         ndr->depth--;
27451 }
27452
27453 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27454 {
27455         if (flags & NDR_IN) {
27456         }
27457         if (flags & NDR_OUT) {
27458                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27459         }
27460         return NDR_ERR_SUCCESS;
27461 }
27462
27463 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27464 {
27465         if (flags & NDR_IN) {
27466         }
27467         if (flags & NDR_OUT) {
27468                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27469         }
27470         return NDR_ERR_SUCCESS;
27471 }
27472
27473 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27474 {
27475         ndr_print_struct(ndr, name, "spoolss_5b");
27476         ndr->depth++;
27477         if (flags & NDR_SET_VALUES) {
27478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27479         }
27480         if (flags & NDR_IN) {
27481                 ndr_print_struct(ndr, "in", "spoolss_5b");
27482                 ndr->depth++;
27483                 ndr->depth--;
27484         }
27485         if (flags & NDR_OUT) {
27486                 ndr_print_struct(ndr, "out", "spoolss_5b");
27487                 ndr->depth++;
27488                 ndr_print_WERROR(ndr, "result", r->out.result);
27489                 ndr->depth--;
27490         }
27491         ndr->depth--;
27492 }
27493
27494 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27495 {
27496         if (flags & NDR_IN) {
27497         }
27498         if (flags & NDR_OUT) {
27499                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27500         }
27501         return NDR_ERR_SUCCESS;
27502 }
27503
27504 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27505 {
27506         if (flags & NDR_IN) {
27507         }
27508         if (flags & NDR_OUT) {
27509                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27510         }
27511         return NDR_ERR_SUCCESS;
27512 }
27513
27514 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27515 {
27516         ndr_print_struct(ndr, name, "spoolss_5c");
27517         ndr->depth++;
27518         if (flags & NDR_SET_VALUES) {
27519                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27520         }
27521         if (flags & NDR_IN) {
27522                 ndr_print_struct(ndr, "in", "spoolss_5c");
27523                 ndr->depth++;
27524                 ndr->depth--;
27525         }
27526         if (flags & NDR_OUT) {
27527                 ndr_print_struct(ndr, "out", "spoolss_5c");
27528                 ndr->depth++;
27529                 ndr_print_WERROR(ndr, "result", r->out.result);
27530                 ndr->depth--;
27531         }
27532         ndr->depth--;
27533 }
27534
27535 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27536 {
27537         if (flags & NDR_IN) {
27538         }
27539         if (flags & NDR_OUT) {
27540                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27541         }
27542         return NDR_ERR_SUCCESS;
27543 }
27544
27545 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27546 {
27547         if (flags & NDR_IN) {
27548         }
27549         if (flags & NDR_OUT) {
27550                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27551         }
27552         return NDR_ERR_SUCCESS;
27553 }
27554
27555 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27556 {
27557         ndr_print_struct(ndr, name, "spoolss_5d");
27558         ndr->depth++;
27559         if (flags & NDR_SET_VALUES) {
27560                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27561         }
27562         if (flags & NDR_IN) {
27563                 ndr_print_struct(ndr, "in", "spoolss_5d");
27564                 ndr->depth++;
27565                 ndr->depth--;
27566         }
27567         if (flags & NDR_OUT) {
27568                 ndr_print_struct(ndr, "out", "spoolss_5d");
27569                 ndr->depth++;
27570                 ndr_print_WERROR(ndr, "result", r->out.result);
27571                 ndr->depth--;
27572         }
27573         ndr->depth--;
27574 }
27575
27576 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27577 {
27578         if (flags & NDR_IN) {
27579         }
27580         if (flags & NDR_OUT) {
27581                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27582         }
27583         return NDR_ERR_SUCCESS;
27584 }
27585
27586 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27587 {
27588         if (flags & NDR_IN) {
27589         }
27590         if (flags & NDR_OUT) {
27591                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27592         }
27593         return NDR_ERR_SUCCESS;
27594 }
27595
27596 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27597 {
27598         ndr_print_struct(ndr, name, "spoolss_5e");
27599         ndr->depth++;
27600         if (flags & NDR_SET_VALUES) {
27601                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27602         }
27603         if (flags & NDR_IN) {
27604                 ndr_print_struct(ndr, "in", "spoolss_5e");
27605                 ndr->depth++;
27606                 ndr->depth--;
27607         }
27608         if (flags & NDR_OUT) {
27609                 ndr_print_struct(ndr, "out", "spoolss_5e");
27610                 ndr->depth++;
27611                 ndr_print_WERROR(ndr, "result", r->out.result);
27612                 ndr->depth--;
27613         }
27614         ndr->depth--;
27615 }
27616
27617 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27618 {
27619         if (flags & NDR_IN) {
27620         }
27621         if (flags & NDR_OUT) {
27622                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27623         }
27624         return NDR_ERR_SUCCESS;
27625 }
27626
27627 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27628 {
27629         if (flags & NDR_IN) {
27630         }
27631         if (flags & NDR_OUT) {
27632                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27633         }
27634         return NDR_ERR_SUCCESS;
27635 }
27636
27637 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27638 {
27639         ndr_print_struct(ndr, name, "spoolss_5f");
27640         ndr->depth++;
27641         if (flags & NDR_SET_VALUES) {
27642                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27643         }
27644         if (flags & NDR_IN) {
27645                 ndr_print_struct(ndr, "in", "spoolss_5f");
27646                 ndr->depth++;
27647                 ndr->depth--;
27648         }
27649         if (flags & NDR_OUT) {
27650                 ndr_print_struct(ndr, "out", "spoolss_5f");
27651                 ndr->depth++;
27652                 ndr_print_WERROR(ndr, "result", r->out.result);
27653                 ndr->depth--;
27654         }
27655         ndr->depth--;
27656 }
27657
27658 static const struct ndr_interface_call spoolss_calls[] = {
27659         {
27660                 "spoolss_EnumPrinters",
27661                 sizeof(struct spoolss_EnumPrinters),
27662                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27663                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27664                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27665                 false,
27666         },
27667         {
27668                 "spoolss_OpenPrinter",
27669                 sizeof(struct spoolss_OpenPrinter),
27670                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27671                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27672                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27673                 false,
27674         },
27675         {
27676                 "spoolss_SetJob",
27677                 sizeof(struct spoolss_SetJob),
27678                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27679                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27680                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27681                 false,
27682         },
27683         {
27684                 "spoolss_GetJob",
27685                 sizeof(struct spoolss_GetJob),
27686                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27687                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27688                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27689                 false,
27690         },
27691         {
27692                 "spoolss_EnumJobs",
27693                 sizeof(struct spoolss_EnumJobs),
27694                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27695                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27696                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27697                 false,
27698         },
27699         {
27700                 "spoolss_AddPrinter",
27701                 sizeof(struct spoolss_AddPrinter),
27702                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27703                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27704                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27705                 false,
27706         },
27707         {
27708                 "spoolss_DeletePrinter",
27709                 sizeof(struct spoolss_DeletePrinter),
27710                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27711                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27712                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27713                 false,
27714         },
27715         {
27716                 "spoolss_SetPrinter",
27717                 sizeof(struct spoolss_SetPrinter),
27718                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27719                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27720                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27721                 false,
27722         },
27723         {
27724                 "spoolss_GetPrinter",
27725                 sizeof(struct spoolss_GetPrinter),
27726                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27727                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27728                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27729                 false,
27730         },
27731         {
27732                 "spoolss_AddPrinterDriver",
27733                 sizeof(struct spoolss_AddPrinterDriver),
27734                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27735                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27736                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27737                 false,
27738         },
27739         {
27740                 "spoolss_EnumPrinterDrivers",
27741                 sizeof(struct spoolss_EnumPrinterDrivers),
27742                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27743                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27744                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27745                 false,
27746         },
27747         {
27748                 "spoolss_GetPrinterDriver",
27749                 sizeof(struct spoolss_GetPrinterDriver),
27750                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27751                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27752                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27753                 false,
27754         },
27755         {
27756                 "spoolss_GetPrinterDriverDirectory",
27757                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27758                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27759                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27760                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27761                 false,
27762         },
27763         {
27764                 "spoolss_DeletePrinterDriver",
27765                 sizeof(struct spoolss_DeletePrinterDriver),
27766                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27767                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27768                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27769                 false,
27770         },
27771         {
27772                 "spoolss_AddPrintProcessor",
27773                 sizeof(struct spoolss_AddPrintProcessor),
27774                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27775                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27776                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27777                 false,
27778         },
27779         {
27780                 "spoolss_EnumPrintProcessors",
27781                 sizeof(struct spoolss_EnumPrintProcessors),
27782                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27783                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27784                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27785                 false,
27786         },
27787         {
27788                 "spoolss_GetPrintProcessorDirectory",
27789                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27790                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27791                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27792                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27793                 false,
27794         },
27795         {
27796                 "spoolss_StartDocPrinter",
27797                 sizeof(struct spoolss_StartDocPrinter),
27798                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27799                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27800                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27801                 false,
27802         },
27803         {
27804                 "spoolss_StartPagePrinter",
27805                 sizeof(struct spoolss_StartPagePrinter),
27806                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27807                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27808                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27809                 false,
27810         },
27811         {
27812                 "spoolss_WritePrinter",
27813                 sizeof(struct spoolss_WritePrinter),
27814                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27815                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27816                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27817                 false,
27818         },
27819         {
27820                 "spoolss_EndPagePrinter",
27821                 sizeof(struct spoolss_EndPagePrinter),
27822                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27823                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27824                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27825                 false,
27826         },
27827         {
27828                 "spoolss_AbortPrinter",
27829                 sizeof(struct spoolss_AbortPrinter),
27830                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27831                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27832                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27833                 false,
27834         },
27835         {
27836                 "spoolss_ReadPrinter",
27837                 sizeof(struct spoolss_ReadPrinter),
27838                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27839                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27840                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27841                 false,
27842         },
27843         {
27844                 "spoolss_EndDocPrinter",
27845                 sizeof(struct spoolss_EndDocPrinter),
27846                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27847                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27848                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27849                 false,
27850         },
27851         {
27852                 "spoolss_AddJob",
27853                 sizeof(struct spoolss_AddJob),
27854                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27855                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27856                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27857                 false,
27858         },
27859         {
27860                 "spoolss_ScheduleJob",
27861                 sizeof(struct spoolss_ScheduleJob),
27862                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27863                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27864                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27865                 false,
27866         },
27867         {
27868                 "spoolss_GetPrinterData",
27869                 sizeof(struct spoolss_GetPrinterData),
27870                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27871                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27872                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27873                 false,
27874         },
27875         {
27876                 "spoolss_SetPrinterData",
27877                 sizeof(struct spoolss_SetPrinterData),
27878                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27879                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27880                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27881                 false,
27882         },
27883         {
27884                 "spoolss_WaitForPrinterChange",
27885                 sizeof(struct spoolss_WaitForPrinterChange),
27886                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27887                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27888                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27889                 false,
27890         },
27891         {
27892                 "spoolss_ClosePrinter",
27893                 sizeof(struct spoolss_ClosePrinter),
27894                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27895                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27896                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27897                 false,
27898         },
27899         {
27900                 "spoolss_AddForm",
27901                 sizeof(struct spoolss_AddForm),
27902                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27903                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27904                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27905                 false,
27906         },
27907         {
27908                 "spoolss_DeleteForm",
27909                 sizeof(struct spoolss_DeleteForm),
27910                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27911                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27912                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27913                 false,
27914         },
27915         {
27916                 "spoolss_GetForm",
27917                 sizeof(struct spoolss_GetForm),
27918                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27919                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27920                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27921                 false,
27922         },
27923         {
27924                 "spoolss_SetForm",
27925                 sizeof(struct spoolss_SetForm),
27926                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27927                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27928                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27929                 false,
27930         },
27931         {
27932                 "spoolss_EnumForms",
27933                 sizeof(struct spoolss_EnumForms),
27934                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27935                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27936                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27937                 false,
27938         },
27939         {
27940                 "spoolss_EnumPorts",
27941                 sizeof(struct spoolss_EnumPorts),
27942                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27943                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27944                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27945                 false,
27946         },
27947         {
27948                 "spoolss_EnumMonitors",
27949                 sizeof(struct spoolss_EnumMonitors),
27950                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27951                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27952                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27953                 false,
27954         },
27955         {
27956                 "spoolss_AddPort",
27957                 sizeof(struct spoolss_AddPort),
27958                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27959                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27960                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27961                 false,
27962         },
27963         {
27964                 "spoolss_ConfigurePort",
27965                 sizeof(struct spoolss_ConfigurePort),
27966                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27967                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27968                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27969                 false,
27970         },
27971         {
27972                 "spoolss_DeletePort",
27973                 sizeof(struct spoolss_DeletePort),
27974                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27975                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27976                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27977                 false,
27978         },
27979         {
27980                 "spoolss_CreatePrinterIC",
27981                 sizeof(struct spoolss_CreatePrinterIC),
27982                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27983                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27984                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27985                 false,
27986         },
27987         {
27988                 "spoolss_PlayGDIScriptOnPrinterIC",
27989                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27990                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27991                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27992                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27993                 false,
27994         },
27995         {
27996                 "spoolss_DeletePrinterIC",
27997                 sizeof(struct spoolss_DeletePrinterIC),
27998                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27999                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
28000                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
28001                 false,
28002         },
28003         {
28004                 "spoolss_AddPrinterConnection",
28005                 sizeof(struct spoolss_AddPrinterConnection),
28006                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
28007                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
28008                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
28009                 false,
28010         },
28011         {
28012                 "spoolss_DeletePrinterConnection",
28013                 sizeof(struct spoolss_DeletePrinterConnection),
28014                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
28015                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
28016                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
28017                 false,
28018         },
28019         {
28020                 "spoolss_PrinterMessageBox",
28021                 sizeof(struct spoolss_PrinterMessageBox),
28022                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
28023                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
28024                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
28025                 false,
28026         },
28027         {
28028                 "spoolss_AddMonitor",
28029                 sizeof(struct spoolss_AddMonitor),
28030                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
28031                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
28032                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
28033                 false,
28034         },
28035         {
28036                 "spoolss_DeleteMonitor",
28037                 sizeof(struct spoolss_DeleteMonitor),
28038                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
28039                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
28040                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
28041                 false,
28042         },
28043         {
28044                 "spoolss_DeletePrintProcessor",
28045                 sizeof(struct spoolss_DeletePrintProcessor),
28046                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
28047                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
28048                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
28049                 false,
28050         },
28051         {
28052                 "spoolss_AddPrintProvidor",
28053                 sizeof(struct spoolss_AddPrintProvidor),
28054                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
28055                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
28056                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
28057                 false,
28058         },
28059         {
28060                 "spoolss_DeletePrintProvidor",
28061                 sizeof(struct spoolss_DeletePrintProvidor),
28062                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
28063                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
28064                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
28065                 false,
28066         },
28067         {
28068                 "spoolss_EnumPrintProcDataTypes",
28069                 sizeof(struct spoolss_EnumPrintProcDataTypes),
28070                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
28071                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
28072                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
28073                 false,
28074         },
28075         {
28076                 "spoolss_ResetPrinter",
28077                 sizeof(struct spoolss_ResetPrinter),
28078                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
28079                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
28080                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
28081                 false,
28082         },
28083         {
28084                 "spoolss_GetPrinterDriver2",
28085                 sizeof(struct spoolss_GetPrinterDriver2),
28086                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
28087                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
28088                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
28089                 false,
28090         },
28091         {
28092                 "spoolss_FindFirstPrinterChangeNotification",
28093                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
28094                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
28095                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
28096                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
28097                 false,
28098         },
28099         {
28100                 "spoolss_FindNextPrinterChangeNotification",
28101                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
28102                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
28103                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
28104                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
28105                 false,
28106         },
28107         {
28108                 "spoolss_FindClosePrinterNotify",
28109                 sizeof(struct spoolss_FindClosePrinterNotify),
28110                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
28111                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
28112                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
28113                 false,
28114         },
28115         {
28116                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
28117                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
28118                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28119                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28120                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28121                 false,
28122         },
28123         {
28124                 "spoolss_ReplyOpenPrinter",
28125                 sizeof(struct spoolss_ReplyOpenPrinter),
28126                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
28127                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
28128                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
28129                 false,
28130         },
28131         {
28132                 "spoolss_RouterReplyPrinter",
28133                 sizeof(struct spoolss_RouterReplyPrinter),
28134                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
28135                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
28136                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
28137                 false,
28138         },
28139         {
28140                 "spoolss_ReplyClosePrinter",
28141                 sizeof(struct spoolss_ReplyClosePrinter),
28142                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
28143                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
28144                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
28145                 false,
28146         },
28147         {
28148                 "spoolss_AddPortEx",
28149                 sizeof(struct spoolss_AddPortEx),
28150                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
28151                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
28152                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
28153                 false,
28154         },
28155         {
28156                 "spoolss_RouterFindFirstPrinterChangeNotification",
28157                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
28158                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
28159                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
28160                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
28161                 false,
28162         },
28163         {
28164                 "spoolss_SpoolerInit",
28165                 sizeof(struct spoolss_SpoolerInit),
28166                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
28167                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
28168                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
28169                 false,
28170         },
28171         {
28172                 "spoolss_ResetPrinterEx",
28173                 sizeof(struct spoolss_ResetPrinterEx),
28174                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
28175                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
28176                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
28177                 false,
28178         },
28179         {
28180                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
28181                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
28182                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28183                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28184                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28185                 false,
28186         },
28187         {
28188                 "spoolss_RouterReplyPrinterEx",
28189                 sizeof(struct spoolss_RouterReplyPrinterEx),
28190                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
28191                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
28192                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
28193                 false,
28194         },
28195         {
28196                 "spoolss_RouterRefreshPrinterChangeNotify",
28197                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
28198                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
28199                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
28200                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
28201                 false,
28202         },
28203         {
28204                 "spoolss_44",
28205                 sizeof(struct spoolss_44),
28206                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
28207                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
28208                 (ndr_print_function_t) ndr_print_spoolss_44,
28209                 false,
28210         },
28211         {
28212                 "spoolss_OpenPrinterEx",
28213                 sizeof(struct spoolss_OpenPrinterEx),
28214                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
28215                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
28216                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
28217                 false,
28218         },
28219         {
28220                 "spoolss_AddPrinterEx",
28221                 sizeof(struct spoolss_AddPrinterEx),
28222                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
28223                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
28224                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
28225                 false,
28226         },
28227         {
28228                 "spoolss_47",
28229                 sizeof(struct spoolss_47),
28230                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
28231                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
28232                 (ndr_print_function_t) ndr_print_spoolss_47,
28233                 false,
28234         },
28235         {
28236                 "spoolss_EnumPrinterData",
28237                 sizeof(struct spoolss_EnumPrinterData),
28238                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
28239                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
28240                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
28241                 false,
28242         },
28243         {
28244                 "spoolss_DeletePrinterData",
28245                 sizeof(struct spoolss_DeletePrinterData),
28246                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
28247                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
28248                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
28249                 false,
28250         },
28251         {
28252                 "spoolss_4a",
28253                 sizeof(struct spoolss_4a),
28254                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
28255                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
28256                 (ndr_print_function_t) ndr_print_spoolss_4a,
28257                 false,
28258         },
28259         {
28260                 "spoolss_4b",
28261                 sizeof(struct spoolss_4b),
28262                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
28263                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
28264                 (ndr_print_function_t) ndr_print_spoolss_4b,
28265                 false,
28266         },
28267         {
28268                 "spoolss_4c",
28269                 sizeof(struct spoolss_4c),
28270                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
28271                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
28272                 (ndr_print_function_t) ndr_print_spoolss_4c,
28273                 false,
28274         },
28275         {
28276                 "spoolss_SetPrinterDataEx",
28277                 sizeof(struct spoolss_SetPrinterDataEx),
28278                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
28279                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
28280                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
28281                 false,
28282         },
28283         {
28284                 "spoolss_GetPrinterDataEx",
28285                 sizeof(struct spoolss_GetPrinterDataEx),
28286                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
28287                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
28288                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
28289                 false,
28290         },
28291         {
28292                 "spoolss_EnumPrinterDataEx",
28293                 sizeof(struct spoolss_EnumPrinterDataEx),
28294                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
28295                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
28296                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
28297                 false,
28298         },
28299         {
28300                 "spoolss_EnumPrinterKey",
28301                 sizeof(struct spoolss_EnumPrinterKey),
28302                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
28303                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
28304                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
28305                 false,
28306         },
28307         {
28308                 "spoolss_DeletePrinterDataEx",
28309                 sizeof(struct spoolss_DeletePrinterDataEx),
28310                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
28311                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
28312                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
28313                 false,
28314         },
28315         {
28316                 "spoolss_DeletePrinterKey",
28317                 sizeof(struct spoolss_DeletePrinterKey),
28318                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
28319                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
28320                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
28321                 false,
28322         },
28323         {
28324                 "spoolss_53",
28325                 sizeof(struct spoolss_53),
28326                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
28327                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
28328                 (ndr_print_function_t) ndr_print_spoolss_53,
28329                 false,
28330         },
28331         {
28332                 "spoolss_DeletePrinterDriverEx",
28333                 sizeof(struct spoolss_DeletePrinterDriverEx),
28334                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
28335                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
28336                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
28337                 false,
28338         },
28339         {
28340                 "spoolss_55",
28341                 sizeof(struct spoolss_55),
28342                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
28343                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
28344                 (ndr_print_function_t) ndr_print_spoolss_55,
28345                 false,
28346         },
28347         {
28348                 "spoolss_56",
28349                 sizeof(struct spoolss_56),
28350                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
28351                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
28352                 (ndr_print_function_t) ndr_print_spoolss_56,
28353                 false,
28354         },
28355         {
28356                 "spoolss_57",
28357                 sizeof(struct spoolss_57),
28358                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
28359                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
28360                 (ndr_print_function_t) ndr_print_spoolss_57,
28361                 false,
28362         },
28363         {
28364                 "spoolss_XcvData",
28365                 sizeof(struct spoolss_XcvData),
28366                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
28367                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
28368                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
28369                 false,
28370         },
28371         {
28372                 "spoolss_AddPrinterDriverEx",
28373                 sizeof(struct spoolss_AddPrinterDriverEx),
28374                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28375                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28376                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28377                 false,
28378         },
28379         {
28380                 "spoolss_5a",
28381                 sizeof(struct spoolss_5a),
28382                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28383                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28384                 (ndr_print_function_t) ndr_print_spoolss_5a,
28385                 false,
28386         },
28387         {
28388                 "spoolss_5b",
28389                 sizeof(struct spoolss_5b),
28390                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28391                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28392                 (ndr_print_function_t) ndr_print_spoolss_5b,
28393                 false,
28394         },
28395         {
28396                 "spoolss_5c",
28397                 sizeof(struct spoolss_5c),
28398                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
28399                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
28400                 (ndr_print_function_t) ndr_print_spoolss_5c,
28401                 false,
28402         },
28403         {
28404                 "spoolss_5d",
28405                 sizeof(struct spoolss_5d),
28406                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
28407                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
28408                 (ndr_print_function_t) ndr_print_spoolss_5d,
28409                 false,
28410         },
28411         {
28412                 "spoolss_5e",
28413                 sizeof(struct spoolss_5e),
28414                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
28415                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28416                 (ndr_print_function_t) ndr_print_spoolss_5e,
28417                 false,
28418         },
28419         {
28420                 "spoolss_5f",
28421                 sizeof(struct spoolss_5f),
28422                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28423                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28424                 (ndr_print_function_t) ndr_print_spoolss_5f,
28425                 false,
28426         },
28427         { NULL, 0, NULL, NULL, NULL, false }
28428 };
28429
28430 static const char * const spoolss_endpoint_strings[] = {
28431         "ncacn_np:[\\pipe\\spoolss]",
28432 };
28433
28434 static const struct ndr_interface_string_array spoolss_endpoints = {
28435         .count  = 1,
28436         .names  = spoolss_endpoint_strings
28437 };
28438
28439 static const char * const spoolss_authservice_strings[] = {
28440         "host",
28441 };
28442
28443 static const struct ndr_interface_string_array spoolss_authservices = {
28444         .count  = 1,
28445         .names  = spoolss_authservice_strings
28446 };
28447
28448
28449 const struct ndr_interface_table ndr_table_spoolss = {
28450         .name           = "spoolss",
28451         .syntax_id      = {
28452                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28453                 NDR_SPOOLSS_VERSION
28454         },
28455         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28456         .num_calls      = 96,
28457         .calls          = spoolss_calls,
28458         .endpoints      = &spoolss_endpoints,
28459         .authservices   = &spoolss_authservices
28460 };
28461