librpc/gen_ndr/ndr_spoolss.c

   1 /* parser auto-generated by pidl */
   2
   3 #include "includes.h"
   4 #include "../librpc/gen_ndr/ndr_spoolss.h"
   5
   6 #include "librpc/gen_ndr/ndr_misc.h"
   7 #include "librpc/gen_ndr/ndr_security.h"
   8 #include "librpc/gen_ndr/ndr_winreg.h"
   9 static enum ndr_err_code ndr_push_spoolss_Time(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Time *r)
  10 {
  11         if (ndr_flags & NDR_SCALARS) {
  12                 NDR_CHECK(ndr_push_align(ndr, 2));
  13                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->year));
  14                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->month));
  15                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day_of_week));
  16                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->day));
  17                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->hour));
  18                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->minute));
  19                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->second));
  20                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->millisecond));
  21         }
  22         if (ndr_flags & NDR_BUFFERS) {
  23         }
  24         return NDR_ERR_SUCCESS;
  25 }
  26
  27 static enum ndr_err_code ndr_pull_spoolss_Time(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Time *r)
  28 {
  29         if (ndr_flags & NDR_SCALARS) {
  30                 NDR_CHECK(ndr_pull_align(ndr, 2));
  31                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->year));
  32                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->month));
  33                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day_of_week));
  34                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->day));
  35                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->hour));
  36                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->minute));
  37                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->second));
  38                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->millisecond));
  39         }
  40         if (ndr_flags & NDR_BUFFERS) {
  41         }
  42         return NDR_ERR_SUCCESS;
  43 }
  44
  45 _PUBLIC_ void ndr_print_spoolss_Time(struct ndr_print *ndr, const char *name, const struct spoolss_Time *r)
  46 {
  47         ndr_print_struct(ndr, name, "spoolss_Time");
  48         ndr->depth++;
  49         ndr_print_uint16(ndr, "year", r->year);
  50         ndr_print_uint16(ndr, "month", r->month);
  51         ndr_print_uint16(ndr, "day_of_week", r->day_of_week);
  52         ndr_print_uint16(ndr, "day", r->day);
  53         ndr_print_uint16(ndr, "hour", r->hour);
  54         ndr_print_uint16(ndr, "minute", r->minute);
  55         ndr_print_uint16(ndr, "second", r->second);
  56         ndr_print_uint16(ndr, "millisecond", r->millisecond);
  57         ndr->depth--;
  58 }
  59
  60 static size_t ndr_size_spoolss_Time(const struct spoolss_Time *r, struct smb_iconv_convenience *ic, int flags)
  61 {
  62         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_Time, ic);
  63 }
  64
  65 static enum ndr_err_code ndr_push_spoolss_TimeCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_TimeCtr *r)
  66 {
  67         if (ndr_flags & NDR_SCALARS) {
  68                 NDR_CHECK(ndr_push_align(ndr, 4));
  69                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags)));
  70                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->time));
  71         }
  72         if (ndr_flags & NDR_BUFFERS) {
  73                 if (r->time) {
  74                         NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, r->time));
  75                 }
  76         }
  77         return NDR_ERR_SUCCESS;
  78 }
  79
  80 static enum ndr_err_code ndr_pull_spoolss_TimeCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_TimeCtr *r)
  81 {
  82         uint32_t _ptr_time;
  83         TALLOC_CTX *_mem_save_time_0;
  84         if (ndr_flags & NDR_SCALARS) {
  85                 NDR_CHECK(ndr_pull_align(ndr, 4));
  86                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
  87                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_time));
  88                 if (_ptr_time) {
  89                         NDR_PULL_ALLOC(ndr, r->time);
  90                 } else {
  91                         r->time = NULL;
  92                 }
  93         }
  94         if (ndr_flags & NDR_BUFFERS) {
  95                 if (r->time) {
  96                         _mem_save_time_0 = NDR_PULL_GET_MEM_CTX(ndr);
  97                         NDR_PULL_SET_MEM_CTX(ndr, r->time, 0);
  98                         NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, r->time));
  99                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_time_0, 0);
 100                 }
 101         }
 102         return NDR_ERR_SUCCESS;
 103 }
 104
 105 _PUBLIC_ void ndr_print_spoolss_TimeCtr(struct ndr_print *ndr, const char *name, const struct spoolss_TimeCtr *r)
 106 {
 107         ndr_print_struct(ndr, name, "spoolss_TimeCtr");
 108         ndr->depth++;
 109         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?ndr_size_spoolss_Time(r->time, ndr->iconv_convenience, ndr->flags):r->size);
 110         ndr_print_ptr(ndr, "time", r->time);
 111         ndr->depth++;
 112         if (r->time) {
 113                 ndr_print_spoolss_Time(ndr, "time", r->time);
 114         }
 115         ndr->depth--;
 116         ndr->depth--;
 117 }
 118
 119 static enum ndr_err_code ndr_push_spoolss_ProcessorArchitecture(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture r)
 120 {
 121         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
 122         return NDR_ERR_SUCCESS;
 123 }
 124
 125 static enum ndr_err_code ndr_pull_spoolss_ProcessorArchitecture(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorArchitecture *r)
 126 {
 127         uint16_t v;
 128         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
 129         *r = v;
 130         return NDR_ERR_SUCCESS;
 131 }
 132
 133 _PUBLIC_ void ndr_print_spoolss_ProcessorArchitecture(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorArchitecture r)
 134 {
 135         const char *val = NULL;
 136
 137         switch (r) {
 138                 case PROCESSOR_ARCHITECTURE_INTEL: val = "PROCESSOR_ARCHITECTURE_INTEL"; break;
 139                 case PROCESSOR_ARCHITECTURE_IA64: val = "PROCESSOR_ARCHITECTURE_IA64"; break;
 140                 case PROCESSOR_ARCHITECTURE_AMD64: val = "PROCESSOR_ARCHITECTURE_AMD64"; break;
 141         }
 142         ndr_print_enum(ndr, name, "ENUM", val, r);
 143 }
 144
 145 static enum ndr_err_code ndr_push_spoolss_ProcessorType(struct ndr_push *ndr, int ndr_flags, enum spoolss_ProcessorType r)
 146 {
 147         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 148         return NDR_ERR_SUCCESS;
 149 }
 150
 151 static enum ndr_err_code ndr_pull_spoolss_ProcessorType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_ProcessorType *r)
 152 {
 153         uint32_t v;
 154         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 155         *r = v;
 156         return NDR_ERR_SUCCESS;
 157 }
 158
 159 _PUBLIC_ void ndr_print_spoolss_ProcessorType(struct ndr_print *ndr, const char *name, enum spoolss_ProcessorType r)
 160 {
 161         const char *val = NULL;
 162
 163         switch (r) {
 164                 case PROCESSOR_INTEL_386: val = "PROCESSOR_INTEL_386"; break;
 165                 case PROCESSOR_INTEL_486: val = "PROCESSOR_INTEL_486"; break;
 166                 case PROCESSOR_INTEL_PENTIUM: val = "PROCESSOR_INTEL_PENTIUM"; break;
 167                 case PROCESSOR_INTEL_IA64: val = "PROCESSOR_INTEL_IA64"; break;
 168                 case PROCESSOR_AMD_X8664: val = "PROCESSOR_AMD_X8664"; break;
 169         }
 170         ndr_print_enum(ndr, name, "ENUM", val, r);
 171 }
 172
 173 static enum ndr_err_code ndr_push_spoolss_MajorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MajorVersion r)
 174 {
 175         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 176         return NDR_ERR_SUCCESS;
 177 }
 178
 179 static enum ndr_err_code ndr_pull_spoolss_MajorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MajorVersion *r)
 180 {
 181         uint32_t v;
 182         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 183         *r = v;
 184         return NDR_ERR_SUCCESS;
 185 }
 186
 187 _PUBLIC_ void ndr_print_spoolss_MajorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MajorVersion r)
 188 {
 189         const char *val = NULL;
 190
 191         switch (r) {
 192                 case SPOOLSS_MAJOR_VERSION_NT4_95_98_ME: val = "SPOOLSS_MAJOR_VERSION_NT4_95_98_ME"; break;
 193                 case SPOOLSS_MAJOR_VERSION_2000_2003_XP: val = "SPOOLSS_MAJOR_VERSION_2000_2003_XP"; break;
 194                 case SPOOLSS_MAJOR_VERSION_2008_VISTA: val = "SPOOLSS_MAJOR_VERSION_2008_VISTA"; break;
 195         }
 196         ndr_print_enum(ndr, name, "ENUM", val, r);
 197 }
 198
 199 static enum ndr_err_code ndr_push_spoolss_MinorVersion(struct ndr_push *ndr, int ndr_flags, enum spoolss_MinorVersion r)
 200 {
 201         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 202         return NDR_ERR_SUCCESS;
 203 }
 204
 205 static enum ndr_err_code ndr_pull_spoolss_MinorVersion(struct ndr_pull *ndr, int ndr_flags, enum spoolss_MinorVersion *r)
 206 {
 207         uint32_t v;
 208         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 209         *r = v;
 210         return NDR_ERR_SUCCESS;
 211 }
 212
 213 _PUBLIC_ void ndr_print_spoolss_MinorVersion(struct ndr_print *ndr, const char *name, enum spoolss_MinorVersion r)
 214 {
 215         const char *val = NULL;
 216
 217         switch (r) {
 218                 case SPOOLSS_MINOR_VERSION_0: val = "SPOOLSS_MINOR_VERSION_0"; break;
 219                 case SPOOLSS_MINOR_VERSION_XP: val = "SPOOLSS_MINOR_VERSION_XP"; break;
 220                 case SPOOLSS_MINOR_VERSION_2003_XP64: val = "SPOOLSS_MINOR_VERSION_2003_XP64"; break;
 221                 case SPOOLSS_MINOR_VERSION_98: val = "SPOOLSS_MINOR_VERSION_98"; break;
 222                 case SPOOLSS_MINOR_VERSION_ME: val = "SPOOLSS_MINOR_VERSION_ME"; break;
 223         }
 224         ndr_print_enum(ndr, name, "ENUM", val, r);
 225 }
 226
 227 static enum ndr_err_code ndr_push_spoolss_PrinterStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 228 {
 229         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 230         return NDR_ERR_SUCCESS;
 231 }
 232
 233 static enum ndr_err_code ndr_pull_spoolss_PrinterStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 234 {
 235         uint32_t v;
 236         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 237         *r = v;
 238         return NDR_ERR_SUCCESS;
 239 }
 240
 241 _PUBLIC_ void ndr_print_spoolss_PrinterStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 242 {
 243         ndr_print_uint32(ndr, name, r);
 244         ndr->depth++;
 245         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAUSED", PRINTER_STATUS_PAUSED, r);
 246         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_ERROR", PRINTER_STATUS_ERROR, r);
 247         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PENDING_DELETION", PRINTER_STATUS_PENDING_DELETION, r);
 248         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_JAM", PRINTER_STATUS_PAPER_JAM, r);
 249         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_OUT", PRINTER_STATUS_PAPER_OUT, r);
 250         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_MANUAL_FEED", PRINTER_STATUS_MANUAL_FEED, r);
 251         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAPER_PROBLEM", PRINTER_STATUS_PAPER_PROBLEM, r);
 252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OFFLINE", PRINTER_STATUS_OFFLINE, r);
 253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_IO_ACTIVE", PRINTER_STATUS_IO_ACTIVE, r);
 254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_BUSY", PRINTER_STATUS_BUSY, r);
 255         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PRINTING", PRINTER_STATUS_PRINTING, r);
 256         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUTPUT_BIN_FULL", PRINTER_STATUS_OUTPUT_BIN_FULL, r);
 257         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NOT_AVAILABLE", PRINTER_STATUS_NOT_AVAILABLE, r);
 258         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WAITING", PRINTER_STATUS_WAITING, r);
 259         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PROCESSING", PRINTER_STATUS_PROCESSING, r);
 260         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_INITIALIZING", PRINTER_STATUS_INITIALIZING, r);
 261         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_WARMING_UP", PRINTER_STATUS_WARMING_UP, r);
 262         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_TONER_LOW", PRINTER_STATUS_TONER_LOW, r);
 263         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_NO_TONER", PRINTER_STATUS_NO_TONER, r);
 264         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_PAGE_PUNT", PRINTER_STATUS_PAGE_PUNT, r);
 265         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_USER_INTERVENTION", PRINTER_STATUS_USER_INTERVENTION, r);
 266         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_OUT_OF_MEMORY", PRINTER_STATUS_OUT_OF_MEMORY, r);
 267         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_DOOR_OPEN", PRINTER_STATUS_DOOR_OPEN, r);
 268         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_SERVER_UNKNOWN", PRINTER_STATUS_SERVER_UNKNOWN, r);
 269         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_STATUS_POWER_SAVE", PRINTER_STATUS_POWER_SAVE, r);
 270         ndr->depth--;
 271 }
 272
 273 static enum ndr_err_code ndr_push_spoolss_JobStatus(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 274 {
 275         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 276         return NDR_ERR_SUCCESS;
 277 }
 278
 279 static enum ndr_err_code ndr_pull_spoolss_JobStatus(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 280 {
 281         uint32_t v;
 282         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 283         *r = v;
 284         return NDR_ERR_SUCCESS;
 285 }
 286
 287 _PUBLIC_ void ndr_print_spoolss_JobStatus(struct ndr_print *ndr, const char *name, uint32_t r)
 288 {
 289         ndr_print_uint32(ndr, name, r);
 290         ndr->depth++;
 291         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAUSED", JOB_STATUS_PAUSED, r);
 292         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_ERROR", JOB_STATUS_ERROR, r);
 293         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETING", JOB_STATUS_DELETING, r);
 294         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_SPOOLING", JOB_STATUS_SPOOLING, r);
 295         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTING", JOB_STATUS_PRINTING, r);
 296         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_OFFLINE", JOB_STATUS_OFFLINE, r);
 297         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PAPEROUT", JOB_STATUS_PAPEROUT, r);
 298         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_PRINTED", JOB_STATUS_PRINTED, r);
 299         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_DELETED", JOB_STATUS_DELETED, r);
 300         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_BLOCKED_DEVQ", JOB_STATUS_BLOCKED_DEVQ, r);
 301         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_USER_INTERVENTION", JOB_STATUS_USER_INTERVENTION, r);
 302         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_RESTART", JOB_STATUS_RESTART, r);
 303         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_STATUS_COMPLETE", JOB_STATUS_COMPLETE, r);
 304         ndr->depth--;
 305 }
 306
 307 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo0(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo0 *r)
 308 {
 309         if (ndr_flags & NDR_SCALARS) {
 310                 NDR_CHECK(ndr_push_align(ndr, 4));
 311                 {
 312                         uint32_t _flags_save_string = ndr->flags;
 313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
 315                         ndr->flags = _flags_save_string;
 316                 }
 317                 {
 318                         uint32_t _flags_save_string = ndr->flags;
 319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 321                         ndr->flags = _flags_save_string;
 322                 }
 323                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
 324                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_jobs));
 325                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_bytes));
 326                 NDR_CHECK(ndr_push_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->global_counter));
 328                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->total_pages));
 329                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->version));
 330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->free_build));
 331                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->spooling));
 332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->max_spooling));
 333                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->session_counter));
 334                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_out_of_paper));
 335                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->num_error_not_ready));
 336                 NDR_CHECK(ndr_push_spoolss_JobStatus(ndr, NDR_SCALARS, r->job_error));
 337                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->number_of_processors));
 338                 NDR_CHECK(ndr_push_spoolss_ProcessorType(ndr, NDR_SCALARS, r->processor_type));
 339                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->high_part_total_bytes));
 340                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->change_id));
 341                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->last_error));
 342                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
 343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->enumerate_network_printers));
 344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->c_setprinter));
 345                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor_architecture));
 346                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->processor_level));
 347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ref_ic));
 348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved3));
 350         }
 351         if (ndr_flags & NDR_BUFFERS) {
 352                 {
 353                         uint32_t _flags_save_string = ndr->flags;
 354                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 355                         if (r->printername) {
 356                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
 357                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
 358                         }
 359                         ndr->flags = _flags_save_string;
 360                 }
 361                 {
 362                         uint32_t _flags_save_string = ndr->flags;
 363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 364                         if (r->servername) {
 365                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
 366                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
 367                         }
 368                         ndr->flags = _flags_save_string;
 369                 }
 370         }
 371         return NDR_ERR_SUCCESS;
 372 }
 373
 374 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo0(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo0 *r)
 375 {
 376         uint32_t _ptr_printername;
 377         TALLOC_CTX *_mem_save_printername_0;
 378         uint32_t _ptr_servername;
 379         TALLOC_CTX *_mem_save_servername_0;
 380         if (ndr_flags & NDR_SCALARS) {
 381                 NDR_CHECK(ndr_pull_align(ndr, 4));
 382                 {
 383                         uint32_t _flags_save_string = ndr->flags;
 384                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 385                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
 386                         if (_ptr_printername) {
 387                                 NDR_PULL_ALLOC(ndr, r->printername);
 388                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
 389                         } else {
 390                                 r->printername = NULL;
 391                         }
 392                         ndr->flags = _flags_save_string;
 393                 }
 394                 {
 395                         uint32_t _flags_save_string = ndr->flags;
 396                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 397                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
 398                         if (_ptr_servername) {
 399                                 NDR_PULL_ALLOC(ndr, r->servername);
 400                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
 401                         } else {
 402                                 r->servername = NULL;
 403                         }
 404                         ndr->flags = _flags_save_string;
 405                 }
 406                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->cjobs));
 407                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_jobs));
 408                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_bytes));
 409                 NDR_CHECK(ndr_pull_spoolss_Time(ndr, NDR_SCALARS, &r->time));
 410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->global_counter));
 411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->total_pages));
 412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
 413                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->free_build));
 414                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->spooling));
 415                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->max_spooling));
 416                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->session_counter));
 417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_out_of_paper));
 418                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->num_error_not_ready));
 419                 NDR_CHECK(ndr_pull_spoolss_JobStatus(ndr, NDR_SCALARS, &r->job_error));
 420                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->number_of_processors));
 421                 NDR_CHECK(ndr_pull_spoolss_ProcessorType(ndr, NDR_SCALARS, &r->processor_type));
 422                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->high_part_total_bytes));
 423                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->change_id));
 424                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->last_error));
 425                 NDR_CHECK(ndr_pull_spoolss_PrinterStatus(ndr, NDR_SCALARS, &r->status));
 426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->enumerate_network_printers));
 427                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->c_setprinter));
 428                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor_architecture));
 429                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->processor_level));
 430                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ref_ic));
 431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 432                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved3));
 433         }
 434         if (ndr_flags & NDR_BUFFERS) {
 435                 {
 436                         uint32_t _flags_save_string = ndr->flags;
 437                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 438                         if (r->printername) {
 439                                 uint32_t _relative_save_offset;
 440                                 _relative_save_offset = ndr->offset;
 441                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->printername));
 442                                 _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 443                                 NDR_PULL_SET_MEM_CTX(ndr, r->printername, 0);
 444                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->printername));
 445                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
 446                                 ndr->offset = _relative_save_offset;
 447                         }
 448                         ndr->flags = _flags_save_string;
 449                 }
 450                 {
 451                         uint32_t _flags_save_string = ndr->flags;
 452                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 453                         if (r->servername) {
 454                                 uint32_t _relative_save_offset;
 455                                 _relative_save_offset = ndr->offset;
 456                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->servername));
 457                                 _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
 458                                 NDR_PULL_SET_MEM_CTX(ndr, r->servername, 0);
 459                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->servername));
 460                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
 461                                 ndr->offset = _relative_save_offset;
 462                         }
 463                         ndr->flags = _flags_save_string;
 464                 }
 465         }
 466         return NDR_ERR_SUCCESS;
 467 }
 468
 469 _PUBLIC_ void ndr_print_spoolss_PrinterInfo0(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo0 *r)
 470 {
 471         ndr_print_struct(ndr, name, "spoolss_PrinterInfo0");
 472         ndr->depth++;
 473         ndr_print_ptr(ndr, "printername", r->printername);
 474         ndr->depth++;
 475         if (r->printername) {
 476                 ndr_print_string(ndr, "printername", r->printername);
 477         }
 478         ndr->depth--;
 479         ndr_print_ptr(ndr, "servername", r->servername);
 480         ndr->depth++;
 481         if (r->servername) {
 482                 ndr_print_string(ndr, "servername", r->servername);
 483         }
 484         ndr->depth--;
 485         ndr_print_uint32(ndr, "cjobs", r->cjobs);
 486         ndr_print_uint32(ndr, "total_jobs", r->total_jobs);
 487         ndr_print_uint32(ndr, "total_bytes", r->total_bytes);
 488         ndr_print_spoolss_Time(ndr, "time", &r->time);
 489         ndr_print_uint32(ndr, "global_counter", r->global_counter);
 490         ndr_print_uint32(ndr, "total_pages", r->total_pages);
 491         ndr_print_uint32(ndr, "version", r->version);
 492         ndr_print_uint32(ndr, "free_build", r->free_build);
 493         ndr_print_uint32(ndr, "spooling", r->spooling);
 494         ndr_print_uint32(ndr, "max_spooling", r->max_spooling);
 495         ndr_print_uint32(ndr, "session_counter", r->session_counter);
 496         ndr_print_uint32(ndr, "num_error_out_of_paper", r->num_error_out_of_paper);
 497         ndr_print_uint32(ndr, "num_error_not_ready", r->num_error_not_ready);
 498         ndr_print_spoolss_JobStatus(ndr, "job_error", r->job_error);
 499         ndr_print_uint32(ndr, "number_of_processors", r->number_of_processors);
 500         ndr_print_spoolss_ProcessorType(ndr, "processor_type", r->processor_type);
 501         ndr_print_uint32(ndr, "high_part_total_bytes", r->high_part_total_bytes);
 502         ndr_print_uint32(ndr, "change_id", r->change_id);
 503         ndr_print_WERROR(ndr, "last_error", r->last_error);
 504         ndr_print_spoolss_PrinterStatus(ndr, "status", r->status);
 505         ndr_print_uint32(ndr, "enumerate_network_printers", r->enumerate_network_printers);
 506         ndr_print_uint32(ndr, "c_setprinter", r->c_setprinter);
 507         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor_architecture", r->processor_architecture);
 508         ndr_print_uint16(ndr, "processor_level", r->processor_level);
 509         ndr_print_uint32(ndr, "ref_ic", r->ref_ic);
 510         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 511         ndr_print_uint32(ndr, "reserved3", r->reserved3);
 512         ndr->depth--;
 513 }
 514
 515 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo0(const struct spoolss_PrinterInfo0 *r, struct smb_iconv_convenience *ic, int flags)
 516 {
 517         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo0, ic);
 518 }
 519
 520 static enum ndr_err_code ndr_push_spoolss_DeviceModeFields(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 521 {
 522         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 523         return NDR_ERR_SUCCESS;
 524 }
 525
 526 static enum ndr_err_code ndr_pull_spoolss_DeviceModeFields(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 527 {
 528         uint32_t v;
 529         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 530         *r = v;
 531         return NDR_ERR_SUCCESS;
 532 }
 533
 534 _PUBLIC_ void ndr_print_spoolss_DeviceModeFields(struct ndr_print *ndr, const char *name, uint32_t r)
 535 {
 536         ndr_print_uint32(ndr, name, r);
 537         ndr->depth++;
 538         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ORIENTATION", DEVMODE_ORIENTATION, r);
 539         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERSIZE", DEVMODE_PAPERSIZE, r);
 540         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERLENGTH", DEVMODE_PAPERLENGTH, r);
 541         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PAPERWIDTH", DEVMODE_PAPERWIDTH, r);
 542         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_SCALE", DEVMODE_SCALE, r);
 543         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_POSITION", DEVMODE_POSITION, r);
 544         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_NUP", DEVMODE_NUP, r);
 545         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COPIES", DEVMODE_COPIES, r);
 546         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DEFAULTSOURCE", DEVMODE_DEFAULTSOURCE, r);
 547         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PRINTQUALITY", DEVMODE_PRINTQUALITY, r);
 548         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLOR", DEVMODE_COLOR, r);
 549         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DUPLEX", DEVMODE_DUPLEX, r);
 550         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_YRESOLUTION", DEVMODE_YRESOLUTION, r);
 551         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_TTOPTION", DEVMODE_TTOPTION, r);
 552         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_COLLATE", DEVMODE_COLLATE, r);
 553         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_FORMNAME", DEVMODE_FORMNAME, r);
 554         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_LOGPIXELS", DEVMODE_LOGPIXELS, r);
 555         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_BITSPERPEL", DEVMODE_BITSPERPEL, r);
 556         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSWIDTH", DEVMODE_PELSWIDTH, r);
 557         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PELSHEIGHT", DEVMODE_PELSHEIGHT, r);
 558         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFLAGS", DEVMODE_DISPLAYFLAGS, r);
 559         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DISPLAYFREQUENCY", DEVMODE_DISPLAYFREQUENCY, r);
 560         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMMETHOD", DEVMODE_ICMMETHOD, r);
 561         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_ICMINTENT", DEVMODE_ICMINTENT, r);
 562         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_MEDIATYPE", DEVMODE_MEDIATYPE, r);
 563         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_DITHERTYPE", DEVMODE_DITHERTYPE, r);
 564         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGWIDTH", DEVMODE_PANNINGWIDTH, r);
 565         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DEVMODE_PANNINGHEIGHT", DEVMODE_PANNINGHEIGHT, r);
 566         ndr->depth--;
 567 }
 568
 569 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeviceMode(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DeviceMode *r)
 570 {
 571         if (ndr_flags & NDR_SCALARS) {
 572                 NDR_CHECK(ndr_push_align(ndr, 4));
 573                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 574                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->specversion));
 575                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverversion));
 576                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->size));
 577                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->driverextra_data.length));
 578                 NDR_CHECK(ndr_push_spoolss_DeviceModeFields(ndr, NDR_SCALARS, r->fields));
 579                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->orientation));
 580                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->papersize));
 581                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperlength));
 582                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->paperwidth));
 583                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->scale));
 584                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->copies));
 585                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->defaultsource));
 586                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->printquality));
 587                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->color));
 588                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->duplex));
 589                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->yresolution));
 590                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->ttoption));
 591                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->collate));
 592                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->formname, 32, sizeof(uint16_t), CH_UTF16));
 593                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->logpixels));
 594                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bitsperpel));
 595                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelswidth));
 596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->pelsheight));
 597                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayflags));
 598                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->displayfrequency));
 599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmmethod));
 600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->icmintent));
 601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->mediatype));
 602                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dithertype));
 603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved1));
 604                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved2));
 605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningwidth));
 606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->panningheight));
 607                 {
 608                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 609                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 610                         {
 611                                 struct ndr_push *_ndr_driverextra_data;
 612                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->driverextra_data.length));
 613                                 NDR_CHECK(ndr_push_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, r->driverextra_data));
 614                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_driverextra_data, 0, r->driverextra_data.length));
 615                         }
 616                         ndr->flags = _flags_save_DATA_BLOB;
 617                 }
 618         }
 619         if (ndr_flags & NDR_BUFFERS) {
 620         }
 621         return NDR_ERR_SUCCESS;
 622 }
 623
 624 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeviceMode(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DeviceMode *r)
 625 {
 626         if (ndr_flags & NDR_SCALARS) {
 627                 NDR_CHECK(ndr_pull_align(ndr, 4));
 628                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->devicename, 32, sizeof(uint16_t), CH_UTF16));
 629                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->specversion));
 630                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->driverversion));
 631                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->size));
 632                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->__driverextra_length));
 633                 NDR_CHECK(ndr_pull_spoolss_DeviceModeFields(ndr, NDR_SCALARS, &r->fields));
 634                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->orientation));
 635                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->papersize));
 636                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperlength));
 637                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->paperwidth));
 638                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->scale));
 639                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->copies));
 640                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->defaultsource));
 641                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->printquality));
 642                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->color));
 643                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->duplex));
 644                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->yresolution));
 645                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->ttoption));
 646                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->collate));
 647                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->formname, 32, sizeof(uint16_t), CH_UTF16));
 648                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->logpixels));
 649                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bitsperpel));
 650                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelswidth));
 651                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->pelsheight));
 652                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayflags));
 653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->displayfrequency));
 654                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmmethod));
 655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->icmintent));
 656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->mediatype));
 657                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dithertype));
 658                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved1));
 659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved2));
 660                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningwidth));
 661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->panningheight));
 662                 {
 663                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
 664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
 665                         {
 666                                 struct ndr_pull *_ndr_driverextra_data;
 667                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_driverextra_data, 0, r->__driverextra_length));
 668                                 NDR_CHECK(ndr_pull_DATA_BLOB(_ndr_driverextra_data, NDR_SCALARS, &r->driverextra_data));
 669                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_driverextra_data, 0, r->__driverextra_length));
 670                         }
 671                         ndr->flags = _flags_save_DATA_BLOB;
 672                 }
 673         }
 674         if (ndr_flags & NDR_BUFFERS) {
 675         }
 676         return NDR_ERR_SUCCESS;
 677 }
 678
 679 _PUBLIC_ void ndr_print_spoolss_DeviceMode(struct ndr_print *ndr, const char *name, const struct spoolss_DeviceMode *r)
 680 {
 681         ndr_print_struct(ndr, name, "spoolss_DeviceMode");
 682         ndr->depth++;
 683         ndr_print_string(ndr, "devicename", r->devicename);
 684         ndr_print_uint16(ndr, "specversion", r->specversion);
 685         ndr_print_uint16(ndr, "driverversion", r->driverversion);
 686         ndr_print_uint16(ndr, "size", r->size);
 687         ndr_print_uint16(ndr, "__driverextra_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->driverextra_data.length:r->__driverextra_length);
 688         ndr_print_spoolss_DeviceModeFields(ndr, "fields", r->fields);
 689         ndr_print_uint16(ndr, "orientation", r->orientation);
 690         ndr_print_uint16(ndr, "papersize", r->papersize);
 691         ndr_print_uint16(ndr, "paperlength", r->paperlength);
 692         ndr_print_uint16(ndr, "paperwidth", r->paperwidth);
 693         ndr_print_uint16(ndr, "scale", r->scale);
 694         ndr_print_uint16(ndr, "copies", r->copies);
 695         ndr_print_uint16(ndr, "defaultsource", r->defaultsource);
 696         ndr_print_uint16(ndr, "printquality", r->printquality);
 697         ndr_print_uint16(ndr, "color", r->color);
 698         ndr_print_uint16(ndr, "duplex", r->duplex);
 699         ndr_print_uint16(ndr, "yresolution", r->yresolution);
 700         ndr_print_uint16(ndr, "ttoption", r->ttoption);
 701         ndr_print_uint16(ndr, "collate", r->collate);
 702         ndr_print_string(ndr, "formname", r->formname);
 703         ndr_print_uint16(ndr, "logpixels", r->logpixels);
 704         ndr_print_uint32(ndr, "bitsperpel", r->bitsperpel);
 705         ndr_print_uint32(ndr, "pelswidth", r->pelswidth);
 706         ndr_print_uint32(ndr, "pelsheight", r->pelsheight);
 707         ndr_print_uint32(ndr, "displayflags", r->displayflags);
 708         ndr_print_uint32(ndr, "displayfrequency", r->displayfrequency);
 709         ndr_print_uint32(ndr, "icmmethod", r->icmmethod);
 710         ndr_print_uint32(ndr, "icmintent", r->icmintent);
 711         ndr_print_uint32(ndr, "mediatype", r->mediatype);
 712         ndr_print_uint32(ndr, "dithertype", r->dithertype);
 713         ndr_print_uint32(ndr, "reserved1", r->reserved1);
 714         ndr_print_uint32(ndr, "reserved2", r->reserved2);
 715         ndr_print_uint32(ndr, "panningwidth", r->panningwidth);
 716         ndr_print_uint32(ndr, "panningheight", r->panningheight);
 717         ndr_print_DATA_BLOB(ndr, "driverextra_data", r->driverextra_data);
 718         ndr->depth--;
 719 }
 720
 721 _PUBLIC_ size_t ndr_size_spoolss_DeviceMode(const struct spoolss_DeviceMode *r, struct smb_iconv_convenience *ic, int flags)
 722 {
 723         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DeviceMode, ic);
 724 }
 725
 726 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 727 {
 728         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 729         return NDR_ERR_SUCCESS;
 730 }
 731
 732 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 733 {
 734         uint32_t v;
 735         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 736         *r = v;
 737         return NDR_ERR_SUCCESS;
 738 }
 739
 740 _PUBLIC_ void ndr_print_spoolss_EnumPrinterFlags(struct ndr_print *ndr, const char *name, uint32_t r)
 741 {
 742         ndr_print_uint32(ndr, name, r);
 743         ndr->depth++;
 744         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_DEFAULT", PRINTER_ENUM_DEFAULT, r);
 745         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_LOCAL", PRINTER_ENUM_LOCAL, r);
 746         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONNECTIONS", PRINTER_ENUM_CONNECTIONS, r);
 747         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_FAVORITE", PRINTER_ENUM_FAVORITE, r);
 748         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NAME", PRINTER_ENUM_NAME, r);
 749         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_REMOTE", PRINTER_ENUM_REMOTE, r);
 750         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_SHARED", PRINTER_ENUM_SHARED, r);
 751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_NETWORK", PRINTER_ENUM_NETWORK, r);
 752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_EXPAND", PRINTER_ENUM_EXPAND, r);
 753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_CONTAINER", PRINTER_ENUM_CONTAINER, r);
 754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON1", PRINTER_ENUM_ICON1, r);
 755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON2", PRINTER_ENUM_ICON2, r);
 756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON3", PRINTER_ENUM_ICON3, r);
 757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON4", PRINTER_ENUM_ICON4, r);
 758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON5", PRINTER_ENUM_ICON5, r);
 759         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON6", PRINTER_ENUM_ICON6, r);
 760         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON7", PRINTER_ENUM_ICON7, r);
 761         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_ICON8", PRINTER_ENUM_ICON8, r);
 762         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ENUM_HIDE", PRINTER_ENUM_HIDE, r);
 763         ndr->depth--;
 764 }
 765
 766 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo1 *r)
 767 {
 768         if (ndr_flags & NDR_SCALARS) {
 769                 NDR_CHECK(ndr_push_align(ndr, 4));
 770                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->flags));
 771                 {
 772                         uint32_t _flags_save_string = ndr->flags;
 773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 774                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name));
 775                         ndr->flags = _flags_save_string;
 776                 }
 777                 {
 778                         uint32_t _flags_save_string = ndr->flags;
 779                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 780                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
 781                         ndr->flags = _flags_save_string;
 782                 }
 783                 {
 784                         uint32_t _flags_save_string = ndr->flags;
 785                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 786                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
 787                         ndr->flags = _flags_save_string;
 788                 }
 789         }
 790         if (ndr_flags & NDR_BUFFERS) {
 791                 {
 792                         uint32_t _flags_save_string = ndr->flags;
 793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 794                         if (r->name) {
 795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name));
 796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name));
 797                         }
 798                         ndr->flags = _flags_save_string;
 799                 }
 800                 {
 801                         uint32_t _flags_save_string = ndr->flags;
 802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 803                         if (r->description) {
 804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
 805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
 806                         }
 807                         ndr->flags = _flags_save_string;
 808                 }
 809                 {
 810                         uint32_t _flags_save_string = ndr->flags;
 811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 812                         if (r->comment) {
 813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
 814                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
 815                         }
 816                         ndr->flags = _flags_save_string;
 817                 }
 818         }
 819         return NDR_ERR_SUCCESS;
 820 }
 821
 822 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo1 *r)
 823 {
 824         uint32_t _ptr_name;
 825         TALLOC_CTX *_mem_save_name_0;
 826         uint32_t _ptr_description;
 827         TALLOC_CTX *_mem_save_description_0;
 828         uint32_t _ptr_comment;
 829         TALLOC_CTX *_mem_save_comment_0;
 830         if (ndr_flags & NDR_SCALARS) {
 831                 NDR_CHECK(ndr_pull_align(ndr, 4));
 832                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->flags));
 833                 {
 834                         uint32_t _flags_save_string = ndr->flags;
 835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name));
 837                         if (_ptr_name) {
 838                                 NDR_PULL_ALLOC(ndr, r->name);
 839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name, _ptr_name));
 840                         } else {
 841                                 r->name = NULL;
 842                         }
 843                         ndr->flags = _flags_save_string;
 844                 }
 845                 {
 846                         uint32_t _flags_save_string = ndr->flags;
 847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
 849                         if (_ptr_description) {
 850                                 NDR_PULL_ALLOC(ndr, r->description);
 851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
 852                         } else {
 853                                 r->description = NULL;
 854                         }
 855                         ndr->flags = _flags_save_string;
 856                 }
 857                 {
 858                         uint32_t _flags_save_string = ndr->flags;
 859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
 861                         if (_ptr_comment) {
 862                                 NDR_PULL_ALLOC(ndr, r->comment);
 863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
 864                         } else {
 865                                 r->comment = NULL;
 866                         }
 867                         ndr->flags = _flags_save_string;
 868                 }
 869         }
 870         if (ndr_flags & NDR_BUFFERS) {
 871                 {
 872                         uint32_t _flags_save_string = ndr->flags;
 873                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 874                         if (r->name) {
 875                                 uint32_t _relative_save_offset;
 876                                 _relative_save_offset = ndr->offset;
 877                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name));
 878                                 _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
 879                                 NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
 880                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name));
 881                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
 882                                 ndr->offset = _relative_save_offset;
 883                         }
 884                         ndr->flags = _flags_save_string;
 885                 }
 886                 {
 887                         uint32_t _flags_save_string = ndr->flags;
 888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 889                         if (r->description) {
 890                                 uint32_t _relative_save_offset;
 891                                 _relative_save_offset = ndr->offset;
 892                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
 893                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
 894                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
 895                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
 896                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
 897                                 ndr->offset = _relative_save_offset;
 898                         }
 899                         ndr->flags = _flags_save_string;
 900                 }
 901                 {
 902                         uint32_t _flags_save_string = ndr->flags;
 903                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 904                         if (r->comment) {
 905                                 uint32_t _relative_save_offset;
 906                                 _relative_save_offset = ndr->offset;
 907                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->comment));
 908                                 _mem_save_comment_0 = NDR_PULL_GET_MEM_CTX(ndr);
 909                                 NDR_PULL_SET_MEM_CTX(ndr, r->comment, 0);
 910                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->comment));
 911                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_comment_0, 0);
 912                                 ndr->offset = _relative_save_offset;
 913                         }
 914                         ndr->flags = _flags_save_string;
 915                 }
 916         }
 917         return NDR_ERR_SUCCESS;
 918 }
 919
 920 _PUBLIC_ void ndr_print_spoolss_PrinterInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterInfo1 *r)
 921 {
 922         ndr_print_struct(ndr, name, "spoolss_PrinterInfo1");
 923         ndr->depth++;
 924         ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->flags);
 925         ndr_print_ptr(ndr, "name", r->name);
 926         ndr->depth++;
 927         if (r->name) {
 928                 ndr_print_string(ndr, "name", r->name);
 929         }
 930         ndr->depth--;
 931         ndr_print_ptr(ndr, "description", r->description);
 932         ndr->depth++;
 933         if (r->description) {
 934                 ndr_print_string(ndr, "description", r->description);
 935         }
 936         ndr->depth--;
 937         ndr_print_ptr(ndr, "comment", r->comment);
 938         ndr->depth++;
 939         if (r->comment) {
 940                 ndr_print_string(ndr, "comment", r->comment);
 941         }
 942         ndr->depth--;
 943         ndr->depth--;
 944 }
 945
 946 _PUBLIC_ size_t ndr_size_spoolss_PrinterInfo1(const struct spoolss_PrinterInfo1 *r, struct smb_iconv_convenience *ic, int flags)
 947 {
 948         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterInfo1, ic);
 949 }
 950
 951 static enum ndr_err_code ndr_push_spoolss_PrinterAttributes(struct ndr_push *ndr, int ndr_flags, uint32_t r)
 952 {
 953         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
 954         return NDR_ERR_SUCCESS;
 955 }
 956
 957 static enum ndr_err_code ndr_pull_spoolss_PrinterAttributes(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
 958 {
 959         uint32_t v;
 960         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
 961         *r = v;
 962         return NDR_ERR_SUCCESS;
 963 }
 964
 965 _PUBLIC_ void ndr_print_spoolss_PrinterAttributes(struct ndr_print *ndr, const char *name, uint32_t r)
 966 {
 967         ndr_print_uint32(ndr, name, r);
 968         ndr->depth++;
 969         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_QUEUED", PRINTER_ATTRIBUTE_QUEUED, r);
 970         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DIRECT", PRINTER_ATTRIBUTE_DIRECT, r);
 971         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DEFAULT", PRINTER_ATTRIBUTE_DEFAULT, r);
 972         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_SHARED", PRINTER_ATTRIBUTE_SHARED, r);
 973         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_NETWORK", PRINTER_ATTRIBUTE_NETWORK, r);
 974         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_HIDDEN", PRINTER_ATTRIBUTE_HIDDEN, r);
 975         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_LOCAL", PRINTER_ATTRIBUTE_LOCAL, r);
 976         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_DEVQ", PRINTER_ATTRIBUTE_ENABLE_DEVQ, r);
 977         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS", PRINTER_ATTRIBUTE_KEEPPRINTEDJOBS, r);
 978         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST", PRINTER_ATTRIBUTE_DO_COMPLETE_FIRST, r);
 979         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_WORK_OFFLINE", PRINTER_ATTRIBUTE_WORK_OFFLINE, r);
 980         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_ENABLE_BIDI", PRINTER_ATTRIBUTE_ENABLE_BIDI, r);
 981         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_RAW_ONLY", PRINTER_ATTRIBUTE_RAW_ONLY, r);
 982         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_PUBLISHED", PRINTER_ATTRIBUTE_PUBLISHED, r);
 983         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_FAX", PRINTER_ATTRIBUTE_FAX, r);
 984         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ATTRIBUTE_TS", PRINTER_ATTRIBUTE_TS, r);
 985         ndr->depth--;
 986 }
 987
 988 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterInfo2 *r)
 989 {
 990         if (ndr_flags & NDR_SCALARS) {
 991                 NDR_CHECK(ndr_push_align(ndr, 4));
 992                 {
 993                         uint32_t _flags_save_string = ndr->flags;
 994                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
 995                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->servername));
 996                         ndr->flags = _flags_save_string;
 997                 }
 998                 {
 999                         uint32_t _flags_save_string = ndr->flags;
1000                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1001                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printername));
1002                         ndr->flags = _flags_save_string;
1003                 }
1004                 {
1005                         uint32_t _flags_save_string = ndr->flags;
1006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1007                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sharename));
1008                         ndr->flags = _flags_save_string;
1009                 }
1010                 {
1011                         uint32_t _flags_save_string = ndr->flags;
1012                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1013                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->portname));
1014                         ndr->flags = _flags_save_string;
1015                 }
1016                 {
1017                         uint32_t _flags_save_string = ndr->flags;
1018                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1019                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->drivername));
1020                         ndr->flags = _flags_save_string;
1021                 }
1022                 {
1023                         uint32_t _flags_save_string = ndr->flags;
1024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1025                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->comment));
1026                         ndr->flags = _flags_save_string;
1027                 }
1028                 {
1029                         uint32_t _flags_save_string = ndr->flags;
1030                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1031                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->location));
1032                         ndr->flags = _flags_save_string;
1033                 }
1034                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->devmode));
1035                 {
1036                         uint32_t _flags_save_string = ndr->flags;
1037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1038                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->sepfile));
1039                         ndr->flags = _flags_save_string;
1040                 }
1041                 {
1042                         uint32_t _flags_save_string = ndr->flags;
1043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1044                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->printprocessor));
1045                         ndr->flags = _flags_save_string;
1046                 }
1047                 {
1048                         uint32_t _flags_save_string = ndr->flags;
1049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1050                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->datatype));
1051                         ndr->flags = _flags_save_string;
1052                 }
1053                 {
1054                         uint32_t _flags_save_string = ndr->flags;
1055                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1056                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->parameters));
1057                         ndr->flags = _flags_save_string;
1058                 }
1059                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->secdesc));
1060                 NDR_CHECK(ndr_push_spoolss_PrinterAttributes(ndr, NDR_SCALARS, r->attributes));
1061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->priority));
1062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->defaultpriority));
1063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->starttime));
1064                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->untiltime));
1065                 NDR_CHECK(ndr_push_spoolss_PrinterStatus(ndr, NDR_SCALARS, r->status));
1066                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->cjobs));
1067                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->averageppm));
1068         }
1069         if (ndr_flags & NDR_BUFFERS) {
1070                 {
1071                         uint32_t _flags_save_string = ndr->flags;
1072                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1073                         if (r->servername) {
1074                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->servername));
1075                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->servername));
1076                         }
1077                         ndr->flags = _flags_save_string;
1078                 }
1079                 {
1080                         uint32_t _flags_save_string = ndr->flags;
1081                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1082                         if (r->printername) {
1083                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printername));
1084                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printername));
1085                         }
1086                         ndr->flags = _flags_save_string;
1087                 }
1088                 {
1089                         uint32_t _flags_save_string = ndr->flags;
1090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1091                         if (r->sharename) {
1092                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sharename));
1093                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sharename));
1094                         }
1095                         ndr->flags = _flags_save_string;
1096                 }
1097                 {
1098                         uint32_t _flags_save_string = ndr->flags;
1099                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1100                         if (r->portname) {
1101                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->portname));
1102                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->portname));
1103                         }
1104                         ndr->flags = _flags_save_string;
1105                 }
1106                 {
1107                         uint32_t _flags_save_string = ndr->flags;
1108                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1109                         if (r->drivername) {
1110                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->drivername));
1111                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->drivername));
1112                         }
1113                         ndr->flags = _flags_save_string;
1114                 }
1115                 {
1116                         uint32_t _flags_save_string = ndr->flags;
1117                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1118                         if (r->comment) {
1119                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->comment));
1120                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->comment));
1121                         }
1122                         ndr->flags = _flags_save_string;
1123                 }
1124                 {
1125                         uint32_t _flags_save_string = ndr->flags;
1126                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1127                         if (r->location) {
1128                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->location));
1129                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->location));
1130                         }
1131                         ndr->flags = _flags_save_string;
1132                 }
1133                 if (r->devmode) {
1134                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->devmode));
1135                         {
1136                                 struct ndr_push *_ndr_devmode;
1137                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_devmode, 0, -1));
1138                                 NDR_CHECK(ndr_push_spoolss_DeviceMode(_ndr_devmode, NDR_SCALARS, r->devmode));
1139                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_devmode, 0, -1));
1140                         }
1141                 }
1142                 {
1143                         uint32_t _flags_save_string = ndr->flags;
1144                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1145                         if (r->sepfile) {
1146                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->sepfile));
1147                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->sepfile));
1148                         }
1149                         ndr->flags = _flags_save_string;
1150                 }
1151                 {
1152                         uint32_t _flags_save_string = ndr->flags;
1153                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1154                         if (r->printprocessor) {
1155                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->printprocessor));
1156                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->printprocessor));
1157                         }
1158                         ndr->flags = _flags_save_string;
1159                 }
1160                 {
1161                         uint32_t _flags_save_string = ndr->flags;
1162                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1163                         if (r->datatype) {
1164                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->datatype));
1165                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->datatype));
1166                         }
1167                         ndr->flags = _flags_save_string;
1168                 }
1169                 {
1170                         uint32_t _flags_save_string = ndr->flags;
1171                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1172                         if (r->parameters) {
1173                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->parameters));
1174                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->parameters));
1175                         }
1176                         ndr->flags = _flags_save_string;
1177                 }
1178                 if (r->secdesc) {
1179                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->secdesc));
1180                         {
1181                                 struct ndr_push *_ndr_secdesc;
1182                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_secdesc, 0, -1));
1183                                 NDR_CHECK(ndr_push_security_descriptor(_ndr_secdesc, NDR_SCALARS|NDR_BUFFERS, r->secdesc));
1184                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_secdesc, 0, -1));
1185                         }
1186                 }
1187         }
1188         return NDR_ERR_SUCCESS;
1189 }
1190
1191 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterInfo2 *r)
1192 {
1193         uint32_t _ptr_servername;
1194         TALLOC_CTX *_mem_save_servername_0;
1195         uint32_t _ptr_printername;
1196         TALLOC_CTX *_mem_save_printername_0;
1197         uint32_t _ptr_sharename;
1198         TALLOC_CTX *_mem_save_sharename_0;
1199         uint32_t _ptr_portname;
1200         TALLOC_CTX *_mem_save_portname_0;
1201         uint32_t _ptr_drivername;
1202         TALLOC_CTX *_mem_save_drivername_0;
1203         uint32_t _ptr_comment;
1204         TALLOC_CTX *_mem_save_comment_0;
1205         uint32_t _ptr_location;
1206         TALLOC_CTX *_mem_save_location_0;
1207         uint32_t _ptr_devmode;
1208         TALLOC_CTX *_mem_save_devmode_0;
1209         uint32_t _ptr_sepfile;
1210         TALLOC_CTX *_mem_save_sepfile_0;
1211         uint32_t _ptr_printprocessor;
1212         TALLOC_CTX *_mem_save_printprocessor_0;
1213         uint32_t _ptr_datatype;
1214         TALLOC_CTX *_mem_save_datatype_0;
1215         uint32_t _ptr_parameters;
1216         TALLOC_CTX *_mem_save_parameters_0;
1217         uint32_t _ptr_secdesc;
1218         TALLOC_CTX *_mem_save_secdesc_0;
1219         if (ndr_flags & NDR_SCALARS) {
1220                 NDR_CHECK(ndr_pull_align(ndr, 4));
1221                 {
1222                         uint32_t _flags_save_string = ndr->flags;
1223                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1224                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
1225                         if (_ptr_servername) {
1226                                 NDR_PULL_ALLOC(ndr, r->servername);
1227                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->servername, _ptr_servername));
1228                         } else {
1229                                 r->servername = NULL;
1230                         }
1231                         ndr->flags = _flags_save_string;
1232                 }
1233                 {
1234                         uint32_t _flags_save_string = ndr->flags;
1235                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1236                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
1237                         if (_ptr_printername) {
1238                                 NDR_PULL_ALLOC(ndr, r->printername);
1239                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printername, _ptr_printername));
1240                         } else {
1241                                 r->printername = NULL;
1242                         }
1243                         ndr->flags = _flags_save_string;
1244                 }
1245                 {
1246                         uint32_t _flags_save_string = ndr->flags;
1247                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1248                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sharename));
1249                         if (_ptr_sharename) {
1250                                 NDR_PULL_ALLOC(ndr, r->sharename);
1251                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sharename, _ptr_sharename));
1252                         } else {
1253                                 r->sharename = NULL;
1254                         }
1255                         ndr->flags = _flags_save_string;
1256                 }
1257                 {
1258                         uint32_t _flags_save_string = ndr->flags;
1259                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1260                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_portname));
1261                         if (_ptr_portname) {
1262                                 NDR_PULL_ALLOC(ndr, r->portname);
1263                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->portname, _ptr_portname));
1264                         } else {
1265                                 r->portname = NULL;
1266                         }
1267                         ndr->flags = _flags_save_string;
1268                 }
1269                 {
1270                         uint32_t _flags_save_string = ndr->flags;
1271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1272                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_drivername));
1273                         if (_ptr_drivername) {
1274                                 NDR_PULL_ALLOC(ndr, r->drivername);
1275                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->drivername, _ptr_drivername));
1276                         } else {
1277                                 r->drivername = NULL;
1278                         }
1279                         ndr->flags = _flags_save_string;
1280                 }
1281                 {
1282                         uint32_t _flags_save_string = ndr->flags;
1283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1284                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_comment));
1285                         if (_ptr_comment) {
1286                                 NDR_PULL_ALLOC(ndr, r->comment);
1287                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->comment, _ptr_comment));
1288                         } else {
1289                                 r->comment = NULL;
1290                         }
1291                         ndr->flags = _flags_save_string;
1292                 }
1293                 {
1294                         uint32_t _flags_save_string = ndr->flags;
1295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1296                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_location));
1297                         if (_ptr_location) {
1298                                 NDR_PULL_ALLOC(ndr, r->location);
1299                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->location, _ptr_location));
1300                         } else {
1301                                 r->location = NULL;
1302                         }
1303                         ndr->flags = _flags_save_string;
1304                 }
1305                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_devmode));
1306                 if (_ptr_devmode) {
1307                         NDR_PULL_ALLOC(ndr, r->devmode);
1308                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->devmode, _ptr_devmode));
1309                 } else {
1310                         r->devmode = NULL;
1311                 }
1312                 {
1313                         uint32_t _flags_save_string = ndr->flags;
1314                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1315                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_sepfile));
1316                         if (_ptr_sepfile) {
1317                                 NDR_PULL_ALLOC(ndr, r->sepfile);
1318                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->sepfile, _ptr_sepfile));
1319                         } else {
1320                                 r->sepfile = NULL;
1321                         }
1322                         ndr->flags = _flags_save_string;
1323                 }
1324                 {
1325                         uint32_t _flags_save_string = ndr->flags;
1326                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1327                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printprocessor));
1328                         if (_ptr_printprocessor) {
1329                                 NDR_PULL_ALLOC(ndr, r->printprocessor);
1330                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->printprocessor, _ptr_printprocessor));
1331                         } else {
1332                                 r->printprocessor = NULL;
1333                         }
1334                         ndr->flags = _flags_save_string;
1335                 }
1336                 {
1337                         uint32_t _flags_save_string = ndr->flags;
1338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1339                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
1340                         if (_ptr_datatype) {
1341                                 NDR_PULL_ALLOC(ndr, r->datatype);
1342                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->datatype, _ptr_datatype));
1343                         } else {
1344                                 r->datatype = NULL;
1345                         }
1346                         ndr->flags = _flags_save_string;
1347                 }
1348                 {
1349                         uint32_t _flags_save_string = ndr->flags;
1350                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
1351                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_parameters));
1352                         if (_ptr_parameters) {
1353                                 NDR_PULL_ALLOC(ndr, r->parameters);
1354                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->parameters, _ptr_parameters));
1355                         } else {
1356                                 r->parameters = NULL;
1357                         }
1358                         ndr->flags = _flags_save_string;
1359                 }
1360                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_secdesc));
1361                 if (_ptr_secdesc) {
1362                         NDR_PULL_ALLOC(ndr, r->secdesc);
1363                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->secdesc, _ptr_secdesc));
1364                 } else {
1365                         r->secdesc = NULL;
1366                 }
1367                 NDR_CHECK(ndr_pull_spoolss_PrinterAttributes(ndr, NDR_SCALARS, &r->attributes));
1368                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->priority));
1369                 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->name));
5964                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->description));
5965                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->comment));
5966         }
5967         if (ndr_flags & NDR_BUFFERS) {
5968                 if (r->name) {
5969                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->name, 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->name, CH_UTF16)));
5972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->name, ndr_charset_length(r->name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
5973                 }
5974                 if (r->description) {
5975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->description, 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->description, CH_UTF16)));
5978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->description, ndr_charset_length(r->description, 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_name;
5993         TALLOC_CTX *_mem_save_name_0;
5994         uint32_t _ptr_description;
5995         TALLOC_CTX *_mem_save_description_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_name));
6002                 if (_ptr_name) {
6003                         NDR_PULL_ALLOC(ndr, r->name);
6004                 } else {
6005                         r->name = NULL;
6006                 }
6007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
6008                 if (_ptr_description) {
6009                         NDR_PULL_ALLOC(ndr, r->description);
6010                 } else {
6011                         r->description = 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->name) {
6022                         _mem_save_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
6023                         NDR_PULL_SET_MEM_CTX(ndr, r->name, 0);
6024                         NDR_CHECK(ndr_pull_array_size(ndr, &r->name));
6025                         NDR_CHECK(ndr_pull_array_length(ndr, &r->name));
6026                         if (ndr_get_array_length(ndr, &r->name) > ndr_get_array_size(ndr, &r->name)) {
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->name), ndr_get_array_length(ndr, &r->name));
6028                         }
6029                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t)));
6030                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->name, ndr_get_array_length(ndr, &r->name), sizeof(uint16_t), CH_UTF16));
6031                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_0, 0);
6032                 }
6033                 if (r->description) {
6034                         _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
6035                         NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
6036                         NDR_CHECK(ndr_pull_array_size(ndr, &r->description));
6037                         NDR_CHECK(ndr_pull_array_length(ndr, &r->description));
6038                         if (ndr_get_array_length(ndr, &r->description) > ndr_get_array_size(ndr, &r->description)) {
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->description), ndr_get_array_length(ndr, &r->description));
6040                         }
6041                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t)));
6042                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->description, ndr_get_array_length(ndr, &r->description), sizeof(uint16_t), CH_UTF16));
6043                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_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, "name", r->name);
6067         ndr->depth++;
6068         if (r->name) {
6069                 ndr_print_string(ndr, "name", r->name);
6070         }
6071         ndr->depth--;
6072         ndr_print_ptr(ndr, "description", r->description);
6073         ndr->depth++;
6074         if (r->description) {
6075                 ndr_print_string(ndr, "description", r->description);
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_AddDriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo6 *r)
8376 {
8377         if (ndr_flags & NDR_SCALARS) {
8378                 NDR_CHECK(ndr_push_align(ndr, 8));
8379                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8380                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8381                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8382                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8383                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8384                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8385                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8386                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8387                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8389                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8390                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8391                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8392                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8393                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8394                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8395                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8397                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8398         }
8399         if (ndr_flags & NDR_BUFFERS) {
8400                 if (r->driver_name) {
8401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8402                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8403                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8404                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8405                 }
8406                 if (r->architecture) {
8407                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8410                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8411                 }
8412                 if (r->driver_path) {
8413                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8416                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8417                 }
8418                 if (r->data_file) {
8419                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8421                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8422                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8423                 }
8424                 if (r->config_file) {
8425                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8428                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8429                 }
8430                 if (r->help_file) {
8431                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8432                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8433                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8434                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8435                 }
8436                 if (r->monitor_name) {
8437                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8438                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8439                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8440                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8441                 }
8442                 if (r->default_datatype) {
8443                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8444                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8445                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8446                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8447                 }
8448                 if (r->dependent_files) {
8449                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8450                 }
8451                 if (r->previous_names) {
8452                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8453                 }
8454                 if (r->manufacturer_name) {
8455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8459                 }
8460                 if (r->manufacturer_url) {
8461                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8462                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8463                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8464                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8465                 }
8466                 if (r->hardware_id) {
8467                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8468                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8469                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8470                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8471                 }
8472                 if (r->provider) {
8473                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8474                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8475                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8476                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8477                 }
8478         }
8479         return NDR_ERR_SUCCESS;
8480 }
8481
8482 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo6 *r)
8483 {
8484         uint32_t _ptr_driver_name;
8485         TALLOC_CTX *_mem_save_driver_name_0;
8486         uint32_t _ptr_architecture;
8487         TALLOC_CTX *_mem_save_architecture_0;
8488         uint32_t _ptr_driver_path;
8489         TALLOC_CTX *_mem_save_driver_path_0;
8490         uint32_t _ptr_data_file;
8491         TALLOC_CTX *_mem_save_data_file_0;
8492         uint32_t _ptr_config_file;
8493         TALLOC_CTX *_mem_save_config_file_0;
8494         uint32_t _ptr_help_file;
8495         TALLOC_CTX *_mem_save_help_file_0;
8496         uint32_t _ptr_monitor_name;
8497         TALLOC_CTX *_mem_save_monitor_name_0;
8498         uint32_t _ptr_default_datatype;
8499         TALLOC_CTX *_mem_save_default_datatype_0;
8500         uint32_t _ptr_dependent_files;
8501         TALLOC_CTX *_mem_save_dependent_files_0;
8502         uint32_t _ptr_previous_names;
8503         TALLOC_CTX *_mem_save_previous_names_0;
8504         uint32_t _ptr_manufacturer_name;
8505         TALLOC_CTX *_mem_save_manufacturer_name_0;
8506         uint32_t _ptr_manufacturer_url;
8507         TALLOC_CTX *_mem_save_manufacturer_url_0;
8508         uint32_t _ptr_hardware_id;
8509         TALLOC_CTX *_mem_save_hardware_id_0;
8510         uint32_t _ptr_provider;
8511         TALLOC_CTX *_mem_save_provider_0;
8512         if (ndr_flags & NDR_SCALARS) {
8513                 NDR_CHECK(ndr_pull_align(ndr, 8));
8514                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
8515                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
8516                 if (_ptr_driver_name) {
8517                         NDR_PULL_ALLOC(ndr, r->driver_name);
8518                 } else {
8519                         r->driver_name = NULL;
8520                 }
8521                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
8522                 if (_ptr_architecture) {
8523                         NDR_PULL_ALLOC(ndr, r->architecture);
8524                 } else {
8525                         r->architecture = NULL;
8526                 }
8527                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
8528                 if (_ptr_driver_path) {
8529                         NDR_PULL_ALLOC(ndr, r->driver_path);
8530                 } else {
8531                         r->driver_path = NULL;
8532                 }
8533                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
8534                 if (_ptr_data_file) {
8535                         NDR_PULL_ALLOC(ndr, r->data_file);
8536                 } else {
8537                         r->data_file = NULL;
8538                 }
8539                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
8540                 if (_ptr_config_file) {
8541                         NDR_PULL_ALLOC(ndr, r->config_file);
8542                 } else {
8543                         r->config_file = NULL;
8544                 }
8545                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
8546                 if (_ptr_help_file) {
8547                         NDR_PULL_ALLOC(ndr, r->help_file);
8548                 } else {
8549                         r->help_file = NULL;
8550                 }
8551                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
8552                 if (_ptr_monitor_name) {
8553                         NDR_PULL_ALLOC(ndr, r->monitor_name);
8554                 } else {
8555                         r->monitor_name = NULL;
8556                 }
8557                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
8558                 if (_ptr_default_datatype) {
8559                         NDR_PULL_ALLOC(ndr, r->default_datatype);
8560                 } else {
8561                         r->default_datatype = NULL;
8562                 }
8563                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
8564                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
8565                 if (_ptr_dependent_files) {
8566                         NDR_PULL_ALLOC(ndr, r->dependent_files);
8567                 } else {
8568                         r->dependent_files = NULL;
8569                 }
8570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
8571                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
8572                 if (_ptr_previous_names) {
8573                         NDR_PULL_ALLOC(ndr, r->previous_names);
8574                 } else {
8575                         r->previous_names = NULL;
8576                 }
8577                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
8578                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
8579                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
8580                 if (_ptr_manufacturer_name) {
8581                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
8582                 } else {
8583                         r->manufacturer_name = NULL;
8584                 }
8585                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
8586                 if (_ptr_manufacturer_url) {
8587                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
8588                 } else {
8589                         r->manufacturer_url = NULL;
8590                 }
8591                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
8592                 if (_ptr_hardware_id) {
8593                         NDR_PULL_ALLOC(ndr, r->hardware_id);
8594                 } else {
8595                         r->hardware_id = NULL;
8596                 }
8597                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
8598                 if (_ptr_provider) {
8599                         NDR_PULL_ALLOC(ndr, r->provider);
8600                 } else {
8601                         r->provider = NULL;
8602                 }
8603         }
8604         if (ndr_flags & NDR_BUFFERS) {
8605                 if (r->driver_name) {
8606                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8607                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
8608                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
8609                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
8610                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
8611                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
8612                         }
8613                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
8614                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
8615                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
8616                 }
8617                 if (r->architecture) {
8618                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
8619                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
8620                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
8621                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
8622                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
8623                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
8624                         }
8625                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
8626                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
8627                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
8628                 }
8629                 if (r->driver_path) {
8630                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
8631                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
8632                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
8633                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
8634                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
8635                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
8636                         }
8637                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
8638                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
8639                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
8640                 }
8641                 if (r->data_file) {
8642                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8643                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
8644                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
8645                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
8646                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
8647                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
8648                         }
8649                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
8650                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
8651                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
8652                 }
8653                 if (r->config_file) {
8654                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8655                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
8656                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
8657                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
8658                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
8659                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
8660                         }
8661                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
8662                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
8663                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
8664                 }
8665                 if (r->help_file) {
8666                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
8667                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
8668                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
8669                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
8670                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
8671                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
8672                         }
8673                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
8674                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
8675                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
8676                 }
8677                 if (r->monitor_name) {
8678                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8679                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
8680                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
8681                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
8682                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
8683                                 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));
8684                         }
8685                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
8686                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
8687                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
8688                 }
8689                 if (r->default_datatype) {
8690                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
8691                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
8692                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
8693                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
8694                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
8695                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
8696                         }
8697                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
8698                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
8699                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
8700                 }
8701                 if (r->dependent_files) {
8702                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
8703                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
8704                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8705                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
8706                 }
8707                 if (r->previous_names) {
8708                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
8709                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
8710                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8711                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
8712                 }
8713                 if (r->manufacturer_name) {
8714                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
8715                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
8716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
8717                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
8718                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
8719                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
8720                         }
8721                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
8722                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
8723                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
8724                 }
8725                 if (r->manufacturer_url) {
8726                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
8727                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
8728                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
8729                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
8730                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
8731                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
8732                         }
8733                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
8734                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
8735                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
8736                 }
8737                 if (r->hardware_id) {
8738                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
8739                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
8740                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
8741                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
8742                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
8743                                 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));
8744                         }
8745                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
8746                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
8747                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
8748                 }
8749                 if (r->provider) {
8750                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
8751                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
8752                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
8753                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
8754                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
8755                                 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));
8756                         }
8757                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
8758                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
8759                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
8760                 }
8761         }
8762         return NDR_ERR_SUCCESS;
8763 }
8764
8765 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo6 *r)
8766 {
8767         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo6");
8768         ndr->depth++;
8769         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
8770         ndr_print_ptr(ndr, "driver_name", r->driver_name);
8771         ndr->depth++;
8772         if (r->driver_name) {
8773                 ndr_print_string(ndr, "driver_name", r->driver_name);
8774         }
8775         ndr->depth--;
8776         ndr_print_ptr(ndr, "architecture", r->architecture);
8777         ndr->depth++;
8778         if (r->architecture) {
8779                 ndr_print_string(ndr, "architecture", r->architecture);
8780         }
8781         ndr->depth--;
8782         ndr_print_ptr(ndr, "driver_path", r->driver_path);
8783         ndr->depth++;
8784         if (r->driver_path) {
8785                 ndr_print_string(ndr, "driver_path", r->driver_path);
8786         }
8787         ndr->depth--;
8788         ndr_print_ptr(ndr, "data_file", r->data_file);
8789         ndr->depth++;
8790         if (r->data_file) {
8791                 ndr_print_string(ndr, "data_file", r->data_file);
8792         }
8793         ndr->depth--;
8794         ndr_print_ptr(ndr, "config_file", r->config_file);
8795         ndr->depth++;
8796         if (r->config_file) {
8797                 ndr_print_string(ndr, "config_file", r->config_file);
8798         }
8799         ndr->depth--;
8800         ndr_print_ptr(ndr, "help_file", r->help_file);
8801         ndr->depth++;
8802         if (r->help_file) {
8803                 ndr_print_string(ndr, "help_file", r->help_file);
8804         }
8805         ndr->depth--;
8806         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
8807         ndr->depth++;
8808         if (r->monitor_name) {
8809                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
8810         }
8811         ndr->depth--;
8812         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
8813         ndr->depth++;
8814         if (r->default_datatype) {
8815                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
8816         }
8817         ndr->depth--;
8818         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);
8819         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
8820         ndr->depth++;
8821         if (r->dependent_files) {
8822                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
8823         }
8824         ndr->depth--;
8825         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);
8826         ndr_print_ptr(ndr, "previous_names", r->previous_names);
8827         ndr->depth++;
8828         if (r->previous_names) {
8829                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
8830         }
8831         ndr->depth--;
8832         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
8833         ndr_print_hyper(ndr, "driver_version", r->driver_version);
8834         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
8835         ndr->depth++;
8836         if (r->manufacturer_name) {
8837                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
8838         }
8839         ndr->depth--;
8840         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
8841         ndr->depth++;
8842         if (r->manufacturer_url) {
8843                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
8844         }
8845         ndr->depth--;
8846         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
8847         ndr->depth++;
8848         if (r->hardware_id) {
8849                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
8850         }
8851         ndr->depth--;
8852         ndr_print_ptr(ndr, "provider", r->provider);
8853         ndr->depth++;
8854         if (r->provider) {
8855                 ndr_print_string(ndr, "provider", r->provider);
8856         }
8857         ndr->depth--;
8858         ndr->depth--;
8859 }
8860
8861 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfo8 *r)
8862 {
8863         if (ndr_flags & NDR_SCALARS) {
8864                 NDR_CHECK(ndr_push_align(ndr, 8));
8865                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
8866                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_name));
8867                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->architecture));
8868                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->driver_path));
8869                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->data_file));
8870                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->config_file));
8871                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->help_file));
8872                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->monitor_name));
8873                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->default_datatype));
8874                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->dependent_files, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8875                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->dependent_files));
8876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->previous_names, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8877                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->previous_names));
8878                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
8879                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
8880                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_name));
8881                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->manufacturer_url));
8882                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->hardware_id));
8883                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->provider));
8884                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->print_processor));
8885                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->vendor_setup));
8886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->color_profiles, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->color_profiles));
8888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->inf_path));
8889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
8890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ((ndr_size_spoolss_StringArray(r->core_driver_dependencies, ndr->iconv_convenience, ndr->flags) - 4) / 2)));
8891                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->core_driver_dependencies));
8892                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
8893                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
8894         }
8895         if (ndr_flags & NDR_BUFFERS) {
8896                 if (r->driver_name) {
8897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_name, CH_UTF16)));
8900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_name, ndr_charset_length(r->driver_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8901                 }
8902                 if (r->architecture) {
8903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->architecture, CH_UTF16)));
8906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->architecture, ndr_charset_length(r->architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8907                 }
8908                 if (r->driver_path) {
8909                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8910                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8911                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->driver_path, CH_UTF16)));
8912                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->driver_path, ndr_charset_length(r->driver_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8913                 }
8914                 if (r->data_file) {
8915                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8916                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8917                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->data_file, CH_UTF16)));
8918                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->data_file, ndr_charset_length(r->data_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8919                 }
8920                 if (r->config_file) {
8921                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8922                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8923                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->config_file, CH_UTF16)));
8924                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->config_file, ndr_charset_length(r->config_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8925                 }
8926                 if (r->help_file) {
8927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8929                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->help_file, CH_UTF16)));
8930                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->help_file, ndr_charset_length(r->help_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8931                 }
8932                 if (r->monitor_name) {
8933                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8934                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8935                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->monitor_name, CH_UTF16)));
8936                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->monitor_name, ndr_charset_length(r->monitor_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8937                 }
8938                 if (r->default_datatype) {
8939                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8940                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8941                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->default_datatype, CH_UTF16)));
8942                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->default_datatype, ndr_charset_length(r->default_datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8943                 }
8944                 if (r->dependent_files) {
8945                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
8946                 }
8947                 if (r->previous_names) {
8948                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
8949                 }
8950                 if (r->manufacturer_name) {
8951                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8952                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8953                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_name, CH_UTF16)));
8954                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_name, ndr_charset_length(r->manufacturer_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8955                 }
8956                 if (r->manufacturer_url) {
8957                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8958                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8959                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->manufacturer_url, CH_UTF16)));
8960                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->manufacturer_url, ndr_charset_length(r->manufacturer_url, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8961                 }
8962                 if (r->hardware_id) {
8963                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8964                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8965                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->hardware_id, CH_UTF16)));
8966                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_id, ndr_charset_length(r->hardware_id, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8967                 }
8968                 if (r->provider) {
8969                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8970                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8971                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->provider, CH_UTF16)));
8972                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->provider, ndr_charset_length(r->provider, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8973                 }
8974                 if (r->print_processor) {
8975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->print_processor, CH_UTF16)));
8978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->print_processor, ndr_charset_length(r->print_processor, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8979                 }
8980                 if (r->vendor_setup) {
8981                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->vendor_setup, CH_UTF16)));
8984                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->vendor_setup, ndr_charset_length(r->vendor_setup, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8985                 }
8986                 if (r->color_profiles) {
8987                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
8988                 }
8989                 if (r->inf_path) {
8990                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8991                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
8992                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->inf_path, CH_UTF16)));
8993                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->inf_path, ndr_charset_length(r->inf_path, CH_UTF16), sizeof(uint16_t), CH_UTF16));
8994                 }
8995                 if (r->core_driver_dependencies) {
8996                         NDR_CHECK(ndr_push_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
8997                 }
8998         }
8999         return NDR_ERR_SUCCESS;
9000 }
9001
9002 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfo8 *r)
9003 {
9004         uint32_t _ptr_driver_name;
9005         TALLOC_CTX *_mem_save_driver_name_0;
9006         uint32_t _ptr_architecture;
9007         TALLOC_CTX *_mem_save_architecture_0;
9008         uint32_t _ptr_driver_path;
9009         TALLOC_CTX *_mem_save_driver_path_0;
9010         uint32_t _ptr_data_file;
9011         TALLOC_CTX *_mem_save_data_file_0;
9012         uint32_t _ptr_config_file;
9013         TALLOC_CTX *_mem_save_config_file_0;
9014         uint32_t _ptr_help_file;
9015         TALLOC_CTX *_mem_save_help_file_0;
9016         uint32_t _ptr_monitor_name;
9017         TALLOC_CTX *_mem_save_monitor_name_0;
9018         uint32_t _ptr_default_datatype;
9019         TALLOC_CTX *_mem_save_default_datatype_0;
9020         uint32_t _ptr_dependent_files;
9021         TALLOC_CTX *_mem_save_dependent_files_0;
9022         uint32_t _ptr_previous_names;
9023         TALLOC_CTX *_mem_save_previous_names_0;
9024         uint32_t _ptr_manufacturer_name;
9025         TALLOC_CTX *_mem_save_manufacturer_name_0;
9026         uint32_t _ptr_manufacturer_url;
9027         TALLOC_CTX *_mem_save_manufacturer_url_0;
9028         uint32_t _ptr_hardware_id;
9029         TALLOC_CTX *_mem_save_hardware_id_0;
9030         uint32_t _ptr_provider;
9031         TALLOC_CTX *_mem_save_provider_0;
9032         uint32_t _ptr_print_processor;
9033         TALLOC_CTX *_mem_save_print_processor_0;
9034         uint32_t _ptr_vendor_setup;
9035         TALLOC_CTX *_mem_save_vendor_setup_0;
9036         uint32_t _ptr_color_profiles;
9037         TALLOC_CTX *_mem_save_color_profiles_0;
9038         uint32_t _ptr_inf_path;
9039         TALLOC_CTX *_mem_save_inf_path_0;
9040         uint32_t _ptr_core_driver_dependencies;
9041         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
9042         if (ndr_flags & NDR_SCALARS) {
9043                 NDR_CHECK(ndr_pull_align(ndr, 8));
9044                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
9045                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9046                 if (_ptr_driver_name) {
9047                         NDR_PULL_ALLOC(ndr, r->driver_name);
9048                 } else {
9049                         r->driver_name = NULL;
9050                 }
9051                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
9052                 if (_ptr_architecture) {
9053                         NDR_PULL_ALLOC(ndr, r->architecture);
9054                 } else {
9055                         r->architecture = NULL;
9056                 }
9057                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
9058                 if (_ptr_driver_path) {
9059                         NDR_PULL_ALLOC(ndr, r->driver_path);
9060                 } else {
9061                         r->driver_path = NULL;
9062                 }
9063                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
9064                 if (_ptr_data_file) {
9065                         NDR_PULL_ALLOC(ndr, r->data_file);
9066                 } else {
9067                         r->data_file = NULL;
9068                 }
9069                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
9070                 if (_ptr_config_file) {
9071                         NDR_PULL_ALLOC(ndr, r->config_file);
9072                 } else {
9073                         r->config_file = NULL;
9074                 }
9075                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
9076                 if (_ptr_help_file) {
9077                         NDR_PULL_ALLOC(ndr, r->help_file);
9078                 } else {
9079                         r->help_file = NULL;
9080                 }
9081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
9082                 if (_ptr_monitor_name) {
9083                         NDR_PULL_ALLOC(ndr, r->monitor_name);
9084                 } else {
9085                         r->monitor_name = NULL;
9086                 }
9087                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
9088                 if (_ptr_default_datatype) {
9089                         NDR_PULL_ALLOC(ndr, r->default_datatype);
9090                 } else {
9091                         r->default_datatype = NULL;
9092                 }
9093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_dependent_files));
9094                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
9095                 if (_ptr_dependent_files) {
9096                         NDR_PULL_ALLOC(ndr, r->dependent_files);
9097                 } else {
9098                         r->dependent_files = NULL;
9099                 }
9100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_previous_names));
9101                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
9102                 if (_ptr_previous_names) {
9103                         NDR_PULL_ALLOC(ndr, r->previous_names);
9104                 } else {
9105                         r->previous_names = NULL;
9106                 }
9107                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
9108                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
9109                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
9110                 if (_ptr_manufacturer_name) {
9111                         NDR_PULL_ALLOC(ndr, r->manufacturer_name);
9112                 } else {
9113                         r->manufacturer_name = NULL;
9114                 }
9115                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
9116                 if (_ptr_manufacturer_url) {
9117                         NDR_PULL_ALLOC(ndr, r->manufacturer_url);
9118                 } else {
9119                         r->manufacturer_url = NULL;
9120                 }
9121                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
9122                 if (_ptr_hardware_id) {
9123                         NDR_PULL_ALLOC(ndr, r->hardware_id);
9124                 } else {
9125                         r->hardware_id = NULL;
9126                 }
9127                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
9128                 if (_ptr_provider) {
9129                         NDR_PULL_ALLOC(ndr, r->provider);
9130                 } else {
9131                         r->provider = NULL;
9132                 }
9133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
9134                 if (_ptr_print_processor) {
9135                         NDR_PULL_ALLOC(ndr, r->print_processor);
9136                 } else {
9137                         r->print_processor = NULL;
9138                 }
9139                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
9140                 if (_ptr_vendor_setup) {
9141                         NDR_PULL_ALLOC(ndr, r->vendor_setup);
9142                 } else {
9143                         r->vendor_setup = NULL;
9144                 }
9145                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_color_profiles));
9146                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
9147                 if (_ptr_color_profiles) {
9148                         NDR_PULL_ALLOC(ndr, r->color_profiles);
9149                 } else {
9150                         r->color_profiles = NULL;
9151                 }
9152                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
9153                 if (_ptr_inf_path) {
9154                         NDR_PULL_ALLOC(ndr, r->inf_path);
9155                 } else {
9156                         r->inf_path = NULL;
9157                 }
9158                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
9159                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size_core_driver_dependencies));
9160                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
9161                 if (_ptr_core_driver_dependencies) {
9162                         NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
9163                 } else {
9164                         r->core_driver_dependencies = NULL;
9165                 }
9166                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
9167                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
9168         }
9169         if (ndr_flags & NDR_BUFFERS) {
9170                 if (r->driver_name) {
9171                         _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9172                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9173                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_name));
9174                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_name));
9175                         if (ndr_get_array_length(ndr, &r->driver_name) > ndr_get_array_size(ndr, &r->driver_name)) {
9176                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_name), ndr_get_array_length(ndr, &r->driver_name));
9177                         }
9178                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t)));
9179                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_name, ndr_get_array_length(ndr, &r->driver_name), sizeof(uint16_t), CH_UTF16));
9180                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9181                 }
9182                 if (r->architecture) {
9183                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
9184                         NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
9185                         NDR_CHECK(ndr_pull_array_size(ndr, &r->architecture));
9186                         NDR_CHECK(ndr_pull_array_length(ndr, &r->architecture));
9187                         if (ndr_get_array_length(ndr, &r->architecture) > ndr_get_array_size(ndr, &r->architecture)) {
9188                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->architecture), ndr_get_array_length(ndr, &r->architecture));
9189                         }
9190                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t)));
9191                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->architecture, ndr_get_array_length(ndr, &r->architecture), sizeof(uint16_t), CH_UTF16));
9192                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
9193                 }
9194                 if (r->driver_path) {
9195                         _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9196                         NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
9197                         NDR_CHECK(ndr_pull_array_size(ndr, &r->driver_path));
9198                         NDR_CHECK(ndr_pull_array_length(ndr, &r->driver_path));
9199                         if (ndr_get_array_length(ndr, &r->driver_path) > ndr_get_array_size(ndr, &r->driver_path)) {
9200                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->driver_path), ndr_get_array_length(ndr, &r->driver_path));
9201                         }
9202                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t)));
9203                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->driver_path, ndr_get_array_length(ndr, &r->driver_path), sizeof(uint16_t), CH_UTF16));
9204                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
9205                 }
9206                 if (r->data_file) {
9207                         _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9208                         NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
9209                         NDR_CHECK(ndr_pull_array_size(ndr, &r->data_file));
9210                         NDR_CHECK(ndr_pull_array_length(ndr, &r->data_file));
9211                         if (ndr_get_array_length(ndr, &r->data_file) > ndr_get_array_size(ndr, &r->data_file)) {
9212                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->data_file), ndr_get_array_length(ndr, &r->data_file));
9213                         }
9214                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t)));
9215                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->data_file, ndr_get_array_length(ndr, &r->data_file), sizeof(uint16_t), CH_UTF16));
9216                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
9217                 }
9218                 if (r->config_file) {
9219                         _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9220                         NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
9221                         NDR_CHECK(ndr_pull_array_size(ndr, &r->config_file));
9222                         NDR_CHECK(ndr_pull_array_length(ndr, &r->config_file));
9223                         if (ndr_get_array_length(ndr, &r->config_file) > ndr_get_array_size(ndr, &r->config_file)) {
9224                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->config_file), ndr_get_array_length(ndr, &r->config_file));
9225                         }
9226                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t)));
9227                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->config_file, ndr_get_array_length(ndr, &r->config_file), sizeof(uint16_t), CH_UTF16));
9228                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
9229                 }
9230                 if (r->help_file) {
9231                         _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
9232                         NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
9233                         NDR_CHECK(ndr_pull_array_size(ndr, &r->help_file));
9234                         NDR_CHECK(ndr_pull_array_length(ndr, &r->help_file));
9235                         if (ndr_get_array_length(ndr, &r->help_file) > ndr_get_array_size(ndr, &r->help_file)) {
9236                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->help_file), ndr_get_array_length(ndr, &r->help_file));
9237                         }
9238                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t)));
9239                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->help_file, ndr_get_array_length(ndr, &r->help_file), sizeof(uint16_t), CH_UTF16));
9240                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
9241                 }
9242                 if (r->monitor_name) {
9243                         _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9244                         NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
9245                         NDR_CHECK(ndr_pull_array_size(ndr, &r->monitor_name));
9246                         NDR_CHECK(ndr_pull_array_length(ndr, &r->monitor_name));
9247                         if (ndr_get_array_length(ndr, &r->monitor_name) > ndr_get_array_size(ndr, &r->monitor_name)) {
9248                                 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));
9249                         }
9250                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t)));
9251                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->monitor_name, ndr_get_array_length(ndr, &r->monitor_name), sizeof(uint16_t), CH_UTF16));
9252                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
9253                 }
9254                 if (r->default_datatype) {
9255                         _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
9256                         NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
9257                         NDR_CHECK(ndr_pull_array_size(ndr, &r->default_datatype));
9258                         NDR_CHECK(ndr_pull_array_length(ndr, &r->default_datatype));
9259                         if (ndr_get_array_length(ndr, &r->default_datatype) > ndr_get_array_size(ndr, &r->default_datatype)) {
9260                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->default_datatype), ndr_get_array_length(ndr, &r->default_datatype));
9261                         }
9262                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t)));
9263                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->default_datatype, ndr_get_array_length(ndr, &r->default_datatype), sizeof(uint16_t), CH_UTF16));
9264                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
9265                 }
9266                 if (r->dependent_files) {
9267                         _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
9268                         NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
9269                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->dependent_files));
9270                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
9271                 }
9272                 if (r->previous_names) {
9273                         _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
9274                         NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
9275                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->previous_names));
9276                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
9277                 }
9278                 if (r->manufacturer_name) {
9279                         _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9280                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
9281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_name));
9282                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_name));
9283                         if (ndr_get_array_length(ndr, &r->manufacturer_name) > ndr_get_array_size(ndr, &r->manufacturer_name)) {
9284                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_name), ndr_get_array_length(ndr, &r->manufacturer_name));
9285                         }
9286                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t)));
9287                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_name, ndr_get_array_length(ndr, &r->manufacturer_name), sizeof(uint16_t), CH_UTF16));
9288                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
9289                 }
9290                 if (r->manufacturer_url) {
9291                         _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
9292                         NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
9293                         NDR_CHECK(ndr_pull_array_size(ndr, &r->manufacturer_url));
9294                         NDR_CHECK(ndr_pull_array_length(ndr, &r->manufacturer_url));
9295                         if (ndr_get_array_length(ndr, &r->manufacturer_url) > ndr_get_array_size(ndr, &r->manufacturer_url)) {
9296                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->manufacturer_url), ndr_get_array_length(ndr, &r->manufacturer_url));
9297                         }
9298                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t)));
9299                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->manufacturer_url, ndr_get_array_length(ndr, &r->manufacturer_url), sizeof(uint16_t), CH_UTF16));
9300                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
9301                 }
9302                 if (r->hardware_id) {
9303                         _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
9304                         NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
9305                         NDR_CHECK(ndr_pull_array_size(ndr, &r->hardware_id));
9306                         NDR_CHECK(ndr_pull_array_length(ndr, &r->hardware_id));
9307                         if (ndr_get_array_length(ndr, &r->hardware_id) > ndr_get_array_size(ndr, &r->hardware_id)) {
9308                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->hardware_id), ndr_get_array_length(ndr, &r->hardware_id));
9309                         }
9310                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t)));
9311                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_id, ndr_get_array_length(ndr, &r->hardware_id), sizeof(uint16_t), CH_UTF16));
9312                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
9313                 }
9314                 if (r->provider) {
9315                         _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
9316                         NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
9317                         NDR_CHECK(ndr_pull_array_size(ndr, &r->provider));
9318                         NDR_CHECK(ndr_pull_array_length(ndr, &r->provider));
9319                         if (ndr_get_array_length(ndr, &r->provider) > ndr_get_array_size(ndr, &r->provider)) {
9320                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->provider), ndr_get_array_length(ndr, &r->provider));
9321                         }
9322                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t)));
9323                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->provider, ndr_get_array_length(ndr, &r->provider), sizeof(uint16_t), CH_UTF16));
9324                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
9325                 }
9326                 if (r->print_processor) {
9327                         _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
9328                         NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
9329                         NDR_CHECK(ndr_pull_array_size(ndr, &r->print_processor));
9330                         NDR_CHECK(ndr_pull_array_length(ndr, &r->print_processor));
9331                         if (ndr_get_array_length(ndr, &r->print_processor) > ndr_get_array_size(ndr, &r->print_processor)) {
9332                                 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));
9333                         }
9334                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t)));
9335                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->print_processor, ndr_get_array_length(ndr, &r->print_processor), sizeof(uint16_t), CH_UTF16));
9336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
9337                 }
9338                 if (r->vendor_setup) {
9339                         _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
9340                         NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
9341                         NDR_CHECK(ndr_pull_array_size(ndr, &r->vendor_setup));
9342                         NDR_CHECK(ndr_pull_array_length(ndr, &r->vendor_setup));
9343                         if (ndr_get_array_length(ndr, &r->vendor_setup) > ndr_get_array_size(ndr, &r->vendor_setup)) {
9344                                 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));
9345                         }
9346                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t)));
9347                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->vendor_setup, ndr_get_array_length(ndr, &r->vendor_setup), sizeof(uint16_t), CH_UTF16));
9348                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
9349                 }
9350                 if (r->color_profiles) {
9351                         _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
9352                         NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
9353                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->color_profiles));
9354                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
9355                 }
9356                 if (r->inf_path) {
9357                         _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
9358                         NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
9359                         NDR_CHECK(ndr_pull_array_size(ndr, &r->inf_path));
9360                         NDR_CHECK(ndr_pull_array_length(ndr, &r->inf_path));
9361                         if (ndr_get_array_length(ndr, &r->inf_path) > ndr_get_array_size(ndr, &r->inf_path)) {
9362                                 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));
9363                         }
9364                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t)));
9365                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->inf_path, ndr_get_array_length(ndr, &r->inf_path), sizeof(uint16_t), CH_UTF16));
9366                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
9367                 }
9368                 if (r->core_driver_dependencies) {
9369                         _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
9370                         NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
9371                         NDR_CHECK(ndr_pull_spoolss_StringArray(ndr, NDR_SCALARS, r->core_driver_dependencies));
9372                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
9373                 }
9374         }
9375         return NDR_ERR_SUCCESS;
9376 }
9377
9378 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfo8 *r)
9379 {
9380         ndr_print_struct(ndr, name, "spoolss_AddDriverInfo8");
9381         ndr->depth++;
9382         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
9383         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9384         ndr->depth++;
9385         if (r->driver_name) {
9386                 ndr_print_string(ndr, "driver_name", r->driver_name);
9387         }
9388         ndr->depth--;
9389         ndr_print_ptr(ndr, "architecture", r->architecture);
9390         ndr->depth++;
9391         if (r->architecture) {
9392                 ndr_print_string(ndr, "architecture", r->architecture);
9393         }
9394         ndr->depth--;
9395         ndr_print_ptr(ndr, "driver_path", r->driver_path);
9396         ndr->depth++;
9397         if (r->driver_path) {
9398                 ndr_print_string(ndr, "driver_path", r->driver_path);
9399         }
9400         ndr->depth--;
9401         ndr_print_ptr(ndr, "data_file", r->data_file);
9402         ndr->depth++;
9403         if (r->data_file) {
9404                 ndr_print_string(ndr, "data_file", r->data_file);
9405         }
9406         ndr->depth--;
9407         ndr_print_ptr(ndr, "config_file", r->config_file);
9408         ndr->depth++;
9409         if (r->config_file) {
9410                 ndr_print_string(ndr, "config_file", r->config_file);
9411         }
9412         ndr->depth--;
9413         ndr_print_ptr(ndr, "help_file", r->help_file);
9414         ndr->depth++;
9415         if (r->help_file) {
9416                 ndr_print_string(ndr, "help_file", r->help_file);
9417         }
9418         ndr->depth--;
9419         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
9420         ndr->depth++;
9421         if (r->monitor_name) {
9422                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
9423         }
9424         ndr->depth--;
9425         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
9426         ndr->depth++;
9427         if (r->default_datatype) {
9428                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
9429         }
9430         ndr->depth--;
9431         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);
9432         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
9433         ndr->depth++;
9434         if (r->dependent_files) {
9435                 ndr_print_spoolss_StringArray(ndr, "dependent_files", r->dependent_files);
9436         }
9437         ndr->depth--;
9438         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);
9439         ndr_print_ptr(ndr, "previous_names", r->previous_names);
9440         ndr->depth++;
9441         if (r->previous_names) {
9442                 ndr_print_spoolss_StringArray(ndr, "previous_names", r->previous_names);
9443         }
9444         ndr->depth--;
9445         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
9446         ndr_print_hyper(ndr, "driver_version", r->driver_version);
9447         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
9448         ndr->depth++;
9449         if (r->manufacturer_name) {
9450                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
9451         }
9452         ndr->depth--;
9453         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
9454         ndr->depth++;
9455         if (r->manufacturer_url) {
9456                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
9457         }
9458         ndr->depth--;
9459         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
9460         ndr->depth++;
9461         if (r->hardware_id) {
9462                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
9463         }
9464         ndr->depth--;
9465         ndr_print_ptr(ndr, "provider", r->provider);
9466         ndr->depth++;
9467         if (r->provider) {
9468                 ndr_print_string(ndr, "provider", r->provider);
9469         }
9470         ndr->depth--;
9471         ndr_print_ptr(ndr, "print_processor", r->print_processor);
9472         ndr->depth++;
9473         if (r->print_processor) {
9474                 ndr_print_string(ndr, "print_processor", r->print_processor);
9475         }
9476         ndr->depth--;
9477         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
9478         ndr->depth++;
9479         if (r->vendor_setup) {
9480                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
9481         }
9482         ndr->depth--;
9483         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);
9484         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
9485         ndr->depth++;
9486         if (r->color_profiles) {
9487                 ndr_print_spoolss_StringArray(ndr, "color_profiles", r->color_profiles);
9488         }
9489         ndr->depth--;
9490         ndr_print_ptr(ndr, "inf_path", r->inf_path);
9491         ndr->depth++;
9492         if (r->inf_path) {
9493                 ndr_print_string(ndr, "inf_path", r->inf_path);
9494         }
9495         ndr->depth--;
9496         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
9497         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);
9498         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9499         ndr->depth++;
9500         if (r->core_driver_dependencies) {
9501                 ndr_print_spoolss_StringArray(ndr, "core_driver_dependencies", r->core_driver_dependencies);
9502         }
9503         ndr->depth--;
9504         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
9505         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
9506         ndr->depth--;
9507 }
9508
9509 static enum ndr_err_code ndr_push_spoolss_AddDriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddDriverInfo *r)
9510 {
9511         if (ndr_flags & NDR_SCALARS) {
9512                 int level = ndr_push_get_switch_value(ndr, r);
9513                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
9514                 switch (level) {
9515                         case 1: {
9516                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
9517                         break; }
9518
9519                         case 2: {
9520                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
9521                         break; }
9522
9523                         case 3: {
9524                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info3));
9525                         break; }
9526
9527                         case 4: {
9528                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info4));
9529                         break; }
9530
9531                         case 6: {
9532                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info6));
9533                         break; }
9534
9535                         case 8: {
9536                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info8));
9537                         break; }
9538
9539                         default:
9540                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9541                 }
9542         }
9543         if (ndr_flags & NDR_BUFFERS) {
9544                 int level = ndr_push_get_switch_value(ndr, r);
9545                 switch (level) {
9546                         case 1:
9547                                 if (r->info1) {
9548                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9549                                 }
9550                         break;
9551
9552                         case 2:
9553                                 if (r->info2) {
9554                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9555                                 }
9556                         break;
9557
9558                         case 3:
9559                                 if (r->info3) {
9560                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9561                                 }
9562                         break;
9563
9564                         case 4:
9565                                 if (r->info4) {
9566                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9567                                 }
9568                         break;
9569
9570                         case 6:
9571                                 if (r->info6) {
9572                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9573                                 }
9574                         break;
9575
9576                         case 8:
9577                                 if (r->info8) {
9578                                         NDR_CHECK(ndr_push_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9579                                 }
9580                         break;
9581
9582                         default:
9583                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9584                 }
9585         }
9586         return NDR_ERR_SUCCESS;
9587 }
9588
9589 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddDriverInfo *r)
9590 {
9591         int level;
9592         uint32_t _level;
9593         TALLOC_CTX *_mem_save_info1_0;
9594         TALLOC_CTX *_mem_save_info2_0;
9595         TALLOC_CTX *_mem_save_info3_0;
9596         TALLOC_CTX *_mem_save_info4_0;
9597         TALLOC_CTX *_mem_save_info6_0;
9598         TALLOC_CTX *_mem_save_info8_0;
9599         level = ndr_pull_get_switch_value(ndr, r);
9600         if (ndr_flags & NDR_SCALARS) {
9601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
9602                 if (_level != level) {
9603                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
9604                 }
9605                 switch (level) {
9606                         case 1: {
9607                                 uint32_t _ptr_info1;
9608                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
9609                                 if (_ptr_info1) {
9610                                         NDR_PULL_ALLOC(ndr, r->info1);
9611                                 } else {
9612                                         r->info1 = NULL;
9613                                 }
9614                         break; }
9615
9616                         case 2: {
9617                                 uint32_t _ptr_info2;
9618                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
9619                                 if (_ptr_info2) {
9620                                         NDR_PULL_ALLOC(ndr, r->info2);
9621                                 } else {
9622                                         r->info2 = NULL;
9623                                 }
9624                         break; }
9625
9626                         case 3: {
9627                                 uint32_t _ptr_info3;
9628                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info3));
9629                                 if (_ptr_info3) {
9630                                         NDR_PULL_ALLOC(ndr, r->info3);
9631                                 } else {
9632                                         r->info3 = NULL;
9633                                 }
9634                         break; }
9635
9636                         case 4: {
9637                                 uint32_t _ptr_info4;
9638                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info4));
9639                                 if (_ptr_info4) {
9640                                         NDR_PULL_ALLOC(ndr, r->info4);
9641                                 } else {
9642                                         r->info4 = NULL;
9643                                 }
9644                         break; }
9645
9646                         case 6: {
9647                                 uint32_t _ptr_info6;
9648                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info6));
9649                                 if (_ptr_info6) {
9650                                         NDR_PULL_ALLOC(ndr, r->info6);
9651                                 } else {
9652                                         r->info6 = NULL;
9653                                 }
9654                         break; }
9655
9656                         case 8: {
9657                                 uint32_t _ptr_info8;
9658                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info8));
9659                                 if (_ptr_info8) {
9660                                         NDR_PULL_ALLOC(ndr, r->info8);
9661                                 } else {
9662                                         r->info8 = NULL;
9663                                 }
9664                         break; }
9665
9666                         default:
9667                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9668                 }
9669         }
9670         if (ndr_flags & NDR_BUFFERS) {
9671                 switch (level) {
9672                         case 1:
9673                                 if (r->info1) {
9674                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
9675                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
9676                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
9677                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
9678                                 }
9679                         break;
9680
9681                         case 2:
9682                                 if (r->info2) {
9683                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
9684                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
9685                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
9686                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
9687                                 }
9688                         break;
9689
9690                         case 3:
9691                                 if (r->info3) {
9692                                         _mem_save_info3_0 = NDR_PULL_GET_MEM_CTX(ndr);
9693                                         NDR_PULL_SET_MEM_CTX(ndr, r->info3, 0);
9694                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo3(ndr, NDR_SCALARS|NDR_BUFFERS, r->info3));
9695                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info3_0, 0);
9696                                 }
9697                         break;
9698
9699                         case 4:
9700                                 if (r->info4) {
9701                                         _mem_save_info4_0 = NDR_PULL_GET_MEM_CTX(ndr);
9702                                         NDR_PULL_SET_MEM_CTX(ndr, r->info4, 0);
9703                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo4(ndr, NDR_SCALARS|NDR_BUFFERS, r->info4));
9704                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info4_0, 0);
9705                                 }
9706                         break;
9707
9708                         case 6:
9709                                 if (r->info6) {
9710                                         _mem_save_info6_0 = NDR_PULL_GET_MEM_CTX(ndr);
9711                                         NDR_PULL_SET_MEM_CTX(ndr, r->info6, 0);
9712                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo6(ndr, NDR_SCALARS|NDR_BUFFERS, r->info6));
9713                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info6_0, 0);
9714                                 }
9715                         break;
9716
9717                         case 8:
9718                                 if (r->info8) {
9719                                         _mem_save_info8_0 = NDR_PULL_GET_MEM_CTX(ndr);
9720                                         NDR_PULL_SET_MEM_CTX(ndr, r->info8, 0);
9721                                         NDR_CHECK(ndr_pull_spoolss_AddDriverInfo8(ndr, NDR_SCALARS|NDR_BUFFERS, r->info8));
9722                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info8_0, 0);
9723                                 }
9724                         break;
9725
9726                         default:
9727                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
9728                 }
9729         }
9730         return NDR_ERR_SUCCESS;
9731 }
9732
9733 _PUBLIC_ void ndr_print_spoolss_AddDriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddDriverInfo *r)
9734 {
9735         int level;
9736         level = ndr_print_get_switch_value(ndr, r);
9737         ndr_print_union(ndr, name, level, "spoolss_AddDriverInfo");
9738         switch (level) {
9739                 case 1:
9740                         ndr_print_ptr(ndr, "info1", r->info1);
9741                         ndr->depth++;
9742                         if (r->info1) {
9743                                 ndr_print_spoolss_AddDriverInfo1(ndr, "info1", r->info1);
9744                         }
9745                         ndr->depth--;
9746                 break;
9747
9748                 case 2:
9749                         ndr_print_ptr(ndr, "info2", r->info2);
9750                         ndr->depth++;
9751                         if (r->info2) {
9752                                 ndr_print_spoolss_AddDriverInfo2(ndr, "info2", r->info2);
9753                         }
9754                         ndr->depth--;
9755                 break;
9756
9757                 case 3:
9758                         ndr_print_ptr(ndr, "info3", r->info3);
9759                         ndr->depth++;
9760                         if (r->info3) {
9761                                 ndr_print_spoolss_AddDriverInfo3(ndr, "info3", r->info3);
9762                         }
9763                         ndr->depth--;
9764                 break;
9765
9766                 case 4:
9767                         ndr_print_ptr(ndr, "info4", r->info4);
9768                         ndr->depth++;
9769                         if (r->info4) {
9770                                 ndr_print_spoolss_AddDriverInfo4(ndr, "info4", r->info4);
9771                         }
9772                         ndr->depth--;
9773                 break;
9774
9775                 case 6:
9776                         ndr_print_ptr(ndr, "info6", r->info6);
9777                         ndr->depth++;
9778                         if (r->info6) {
9779                                 ndr_print_spoolss_AddDriverInfo6(ndr, "info6", r->info6);
9780                         }
9781                         ndr->depth--;
9782                 break;
9783
9784                 case 8:
9785                         ndr_print_ptr(ndr, "info8", r->info8);
9786                         ndr->depth++;
9787                         if (r->info8) {
9788                                 ndr_print_spoolss_AddDriverInfo8(ndr, "info8", r->info8);
9789                         }
9790                         ndr->depth--;
9791                 break;
9792
9793                 default:
9794                         ndr_print_bad_level(ndr, name, level);
9795         }
9796 }
9797
9798 static enum ndr_err_code ndr_push_spoolss_AddDriverInfoCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddDriverInfoCtr *r)
9799 {
9800         if (ndr_flags & NDR_SCALARS) {
9801                 NDR_CHECK(ndr_push_align(ndr, 4));
9802                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
9803                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->info, r->level));
9804                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9805         }
9806         if (ndr_flags & NDR_BUFFERS) {
9807                 NDR_CHECK(ndr_push_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9808         }
9809         return NDR_ERR_SUCCESS;
9810 }
9811
9812 static enum ndr_err_code ndr_pull_spoolss_AddDriverInfoCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddDriverInfoCtr *r)
9813 {
9814         if (ndr_flags & NDR_SCALARS) {
9815                 NDR_CHECK(ndr_pull_align(ndr, 4));
9816                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
9817                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->info, r->level));
9818                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_SCALARS, &r->info));
9819         }
9820         if (ndr_flags & NDR_BUFFERS) {
9821                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfo(ndr, NDR_BUFFERS, &r->info));
9822         }
9823         return NDR_ERR_SUCCESS;
9824 }
9825
9826 _PUBLIC_ void ndr_print_spoolss_AddDriverInfoCtr(struct ndr_print *ndr, const char *name, const struct spoolss_AddDriverInfoCtr *r)
9827 {
9828         ndr_print_struct(ndr, name, "spoolss_AddDriverInfoCtr");
9829         ndr->depth++;
9830         ndr_print_uint32(ndr, "level", r->level);
9831         ndr_print_set_switch_value(ndr, &r->info, r->level);
9832         ndr_print_spoolss_AddDriverInfo(ndr, "info", &r->info);
9833         ndr->depth--;
9834 }
9835
9836 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo1 *r)
9837 {
9838         if (ndr_flags & NDR_SCALARS) {
9839                 NDR_CHECK(ndr_push_align(ndr, 4));
9840                 {
9841                         uint32_t _flags_save_string = ndr->flags;
9842                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9843                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9844                         ndr->flags = _flags_save_string;
9845                 }
9846         }
9847         if (ndr_flags & NDR_BUFFERS) {
9848                 {
9849                         uint32_t _flags_save_string = ndr->flags;
9850                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9851                         if (r->driver_name) {
9852                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9853                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9854                         }
9855                         ndr->flags = _flags_save_string;
9856                 }
9857         }
9858         return NDR_ERR_SUCCESS;
9859 }
9860
9861 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo1 *r)
9862 {
9863         uint32_t _ptr_driver_name;
9864         TALLOC_CTX *_mem_save_driver_name_0;
9865         if (ndr_flags & NDR_SCALARS) {
9866                 NDR_CHECK(ndr_pull_align(ndr, 4));
9867                 {
9868                         uint32_t _flags_save_string = ndr->flags;
9869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9870                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
9871                         if (_ptr_driver_name) {
9872                                 NDR_PULL_ALLOC(ndr, r->driver_name);
9873                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
9874                         } else {
9875                                 r->driver_name = NULL;
9876                         }
9877                         ndr->flags = _flags_save_string;
9878                 }
9879         }
9880         if (ndr_flags & NDR_BUFFERS) {
9881                 {
9882                         uint32_t _flags_save_string = ndr->flags;
9883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9884                         if (r->driver_name) {
9885                                 uint32_t _relative_save_offset;
9886                                 _relative_save_offset = ndr->offset;
9887                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
9888                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
9889                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
9890                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
9891                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
9892                                 ndr->offset = _relative_save_offset;
9893                         }
9894                         ndr->flags = _flags_save_string;
9895                 }
9896         }
9897         return NDR_ERR_SUCCESS;
9898 }
9899
9900 _PUBLIC_ void ndr_print_spoolss_DriverInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo1 *r)
9901 {
9902         ndr_print_struct(ndr, name, "spoolss_DriverInfo1");
9903         ndr->depth++;
9904         ndr_print_ptr(ndr, "driver_name", r->driver_name);
9905         ndr->depth++;
9906         if (r->driver_name) {
9907                 ndr_print_string(ndr, "driver_name", r->driver_name);
9908         }
9909         ndr->depth--;
9910         ndr->depth--;
9911 }
9912
9913 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo1(const struct spoolss_DriverInfo1 *r, struct smb_iconv_convenience *ic, int flags)
9914 {
9915         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo1, ic);
9916 }
9917
9918 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo2 *r)
9919 {
9920         if (ndr_flags & NDR_SCALARS) {
9921                 NDR_CHECK(ndr_push_align(ndr, 4));
9922                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
9923                 {
9924                         uint32_t _flags_save_string = ndr->flags;
9925                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9926                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
9927                         ndr->flags = _flags_save_string;
9928                 }
9929                 {
9930                         uint32_t _flags_save_string = ndr->flags;
9931                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9932                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
9933                         ndr->flags = _flags_save_string;
9934                 }
9935                 {
9936                         uint32_t _flags_save_string = ndr->flags;
9937                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9938                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
9939                         ndr->flags = _flags_save_string;
9940                 }
9941                 {
9942                         uint32_t _flags_save_string = ndr->flags;
9943                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9944                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
9945                         ndr->flags = _flags_save_string;
9946                 }
9947                 {
9948                         uint32_t _flags_save_string = ndr->flags;
9949                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9950                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
9951                         ndr->flags = _flags_save_string;
9952                 }
9953         }
9954         if (ndr_flags & NDR_BUFFERS) {
9955                 {
9956                         uint32_t _flags_save_string = ndr->flags;
9957                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9958                         if (r->driver_name) {
9959                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
9960                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
9961                         }
9962                         ndr->flags = _flags_save_string;
9963                 }
9964                 {
9965                         uint32_t _flags_save_string = ndr->flags;
9966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9967                         if (r->architecture) {
9968                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
9969                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
9970                         }
9971                         ndr->flags = _flags_save_string;
9972                 }
9973                 {
9974                         uint32_t _flags_save_string = ndr->flags;
9975                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9976                         if (r->driver_path) {
9977                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
9978                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
9979                         }
9980                         ndr->flags = _flags_save_string;
9981                 }
9982                 {
9983                         uint32_t _flags_save_string = ndr->flags;
9984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9985                         if (r->data_file) {
9986                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
9987                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
9988                         }
9989                         ndr->flags = _flags_save_string;
9990                 }
9991                 {
9992                         uint32_t _flags_save_string = ndr->flags;
9993                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
9994                         if (r->config_file) {
9995                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
9996                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
9997                         }
9998                         ndr->flags = _flags_save_string;
9999                 }
10000         }
10001         return NDR_ERR_SUCCESS;
10002 }
10003
10004 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo2 *r)
10005 {
10006         uint32_t _ptr_driver_name;
10007         TALLOC_CTX *_mem_save_driver_name_0;
10008         uint32_t _ptr_architecture;
10009         TALLOC_CTX *_mem_save_architecture_0;
10010         uint32_t _ptr_driver_path;
10011         TALLOC_CTX *_mem_save_driver_path_0;
10012         uint32_t _ptr_data_file;
10013         TALLOC_CTX *_mem_save_data_file_0;
10014         uint32_t _ptr_config_file;
10015         TALLOC_CTX *_mem_save_config_file_0;
10016         if (ndr_flags & NDR_SCALARS) {
10017                 NDR_CHECK(ndr_pull_align(ndr, 4));
10018                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10019                 {
10020                         uint32_t _flags_save_string = ndr->flags;
10021                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10022                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10023                         if (_ptr_driver_name) {
10024                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10025                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10026                         } else {
10027                                 r->driver_name = NULL;
10028                         }
10029                         ndr->flags = _flags_save_string;
10030                 }
10031                 {
10032                         uint32_t _flags_save_string = ndr->flags;
10033                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10034                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10035                         if (_ptr_architecture) {
10036                                 NDR_PULL_ALLOC(ndr, r->architecture);
10037                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10038                         } else {
10039                                 r->architecture = NULL;
10040                         }
10041                         ndr->flags = _flags_save_string;
10042                 }
10043                 {
10044                         uint32_t _flags_save_string = ndr->flags;
10045                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10046                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10047                         if (_ptr_driver_path) {
10048                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10049                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10050                         } else {
10051                                 r->driver_path = NULL;
10052                         }
10053                         ndr->flags = _flags_save_string;
10054                 }
10055                 {
10056                         uint32_t _flags_save_string = ndr->flags;
10057                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10058                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10059                         if (_ptr_data_file) {
10060                                 NDR_PULL_ALLOC(ndr, r->data_file);
10061                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10062                         } else {
10063                                 r->data_file = NULL;
10064                         }
10065                         ndr->flags = _flags_save_string;
10066                 }
10067                 {
10068                         uint32_t _flags_save_string = ndr->flags;
10069                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10070                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10071                         if (_ptr_config_file) {
10072                                 NDR_PULL_ALLOC(ndr, r->config_file);
10073                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10074                         } else {
10075                                 r->config_file = NULL;
10076                         }
10077                         ndr->flags = _flags_save_string;
10078                 }
10079         }
10080         if (ndr_flags & NDR_BUFFERS) {
10081                 {
10082                         uint32_t _flags_save_string = ndr->flags;
10083                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10084                         if (r->driver_name) {
10085                                 uint32_t _relative_save_offset;
10086                                 _relative_save_offset = ndr->offset;
10087                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10088                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10089                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10090                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10091                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10092                                 ndr->offset = _relative_save_offset;
10093                         }
10094                         ndr->flags = _flags_save_string;
10095                 }
10096                 {
10097                         uint32_t _flags_save_string = ndr->flags;
10098                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10099                         if (r->architecture) {
10100                                 uint32_t _relative_save_offset;
10101                                 _relative_save_offset = ndr->offset;
10102                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10103                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10104                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10105                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10106                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10107                                 ndr->offset = _relative_save_offset;
10108                         }
10109                         ndr->flags = _flags_save_string;
10110                 }
10111                 {
10112                         uint32_t _flags_save_string = ndr->flags;
10113                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10114                         if (r->driver_path) {
10115                                 uint32_t _relative_save_offset;
10116                                 _relative_save_offset = ndr->offset;
10117                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10118                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10119                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10120                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10121                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10122                                 ndr->offset = _relative_save_offset;
10123                         }
10124                         ndr->flags = _flags_save_string;
10125                 }
10126                 {
10127                         uint32_t _flags_save_string = ndr->flags;
10128                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10129                         if (r->data_file) {
10130                                 uint32_t _relative_save_offset;
10131                                 _relative_save_offset = ndr->offset;
10132                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10133                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10134                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10135                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10136                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10137                                 ndr->offset = _relative_save_offset;
10138                         }
10139                         ndr->flags = _flags_save_string;
10140                 }
10141                 {
10142                         uint32_t _flags_save_string = ndr->flags;
10143                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10144                         if (r->config_file) {
10145                                 uint32_t _relative_save_offset;
10146                                 _relative_save_offset = ndr->offset;
10147                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10148                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10149                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10150                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10151                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10152                                 ndr->offset = _relative_save_offset;
10153                         }
10154                         ndr->flags = _flags_save_string;
10155                 }
10156         }
10157         return NDR_ERR_SUCCESS;
10158 }
10159
10160 _PUBLIC_ void ndr_print_spoolss_DriverInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo2 *r)
10161 {
10162         ndr_print_struct(ndr, name, "spoolss_DriverInfo2");
10163         ndr->depth++;
10164         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10165         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10166         ndr->depth++;
10167         if (r->driver_name) {
10168                 ndr_print_string(ndr, "driver_name", r->driver_name);
10169         }
10170         ndr->depth--;
10171         ndr_print_ptr(ndr, "architecture", r->architecture);
10172         ndr->depth++;
10173         if (r->architecture) {
10174                 ndr_print_string(ndr, "architecture", r->architecture);
10175         }
10176         ndr->depth--;
10177         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10178         ndr->depth++;
10179         if (r->driver_path) {
10180                 ndr_print_string(ndr, "driver_path", r->driver_path);
10181         }
10182         ndr->depth--;
10183         ndr_print_ptr(ndr, "data_file", r->data_file);
10184         ndr->depth++;
10185         if (r->data_file) {
10186                 ndr_print_string(ndr, "data_file", r->data_file);
10187         }
10188         ndr->depth--;
10189         ndr_print_ptr(ndr, "config_file", r->config_file);
10190         ndr->depth++;
10191         if (r->config_file) {
10192                 ndr_print_string(ndr, "config_file", r->config_file);
10193         }
10194         ndr->depth--;
10195         ndr->depth--;
10196 }
10197
10198 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo2(const struct spoolss_DriverInfo2 *r, struct smb_iconv_convenience *ic, int flags)
10199 {
10200         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo2, ic);
10201 }
10202
10203 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo3 *r)
10204 {
10205         if (ndr_flags & NDR_SCALARS) {
10206                 NDR_CHECK(ndr_push_align(ndr, 4));
10207                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10208                 {
10209                         uint32_t _flags_save_string = ndr->flags;
10210                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10211                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10212                         ndr->flags = _flags_save_string;
10213                 }
10214                 {
10215                         uint32_t _flags_save_string = ndr->flags;
10216                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10217                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10218                         ndr->flags = _flags_save_string;
10219                 }
10220                 {
10221                         uint32_t _flags_save_string = ndr->flags;
10222                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10223                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10224                         ndr->flags = _flags_save_string;
10225                 }
10226                 {
10227                         uint32_t _flags_save_string = ndr->flags;
10228                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10229                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10230                         ndr->flags = _flags_save_string;
10231                 }
10232                 {
10233                         uint32_t _flags_save_string = ndr->flags;
10234                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10235                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10236                         ndr->flags = _flags_save_string;
10237                 }
10238                 {
10239                         uint32_t _flags_save_string = ndr->flags;
10240                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10241                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10242                         ndr->flags = _flags_save_string;
10243                 }
10244                 {
10245                         uint32_t _flags_save_string_array = ndr->flags;
10246                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10247                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10248                         ndr->flags = _flags_save_string_array;
10249                 }
10250                 {
10251                         uint32_t _flags_save_string = ndr->flags;
10252                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10253                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10254                         ndr->flags = _flags_save_string;
10255                 }
10256                 {
10257                         uint32_t _flags_save_string = ndr->flags;
10258                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10259                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10260                         ndr->flags = _flags_save_string;
10261                 }
10262         }
10263         if (ndr_flags & NDR_BUFFERS) {
10264                 {
10265                         uint32_t _flags_save_string = ndr->flags;
10266                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10267                         if (r->driver_name) {
10268                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10269                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10270                         }
10271                         ndr->flags = _flags_save_string;
10272                 }
10273                 {
10274                         uint32_t _flags_save_string = ndr->flags;
10275                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10276                         if (r->architecture) {
10277                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10278                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10279                         }
10280                         ndr->flags = _flags_save_string;
10281                 }
10282                 {
10283                         uint32_t _flags_save_string = ndr->flags;
10284                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10285                         if (r->driver_path) {
10286                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10287                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10288                         }
10289                         ndr->flags = _flags_save_string;
10290                 }
10291                 {
10292                         uint32_t _flags_save_string = ndr->flags;
10293                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10294                         if (r->data_file) {
10295                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10296                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10297                         }
10298                         ndr->flags = _flags_save_string;
10299                 }
10300                 {
10301                         uint32_t _flags_save_string = ndr->flags;
10302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10303                         if (r->config_file) {
10304                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10305                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10306                         }
10307                         ndr->flags = _flags_save_string;
10308                 }
10309                 {
10310                         uint32_t _flags_save_string = ndr->flags;
10311                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10312                         if (r->help_file) {
10313                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10314                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10315                         }
10316                         ndr->flags = _flags_save_string;
10317                 }
10318                 {
10319                         uint32_t _flags_save_string_array = ndr->flags;
10320                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10321                         if (r->dependent_files) {
10322                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10323                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10324                         }
10325                         ndr->flags = _flags_save_string_array;
10326                 }
10327                 {
10328                         uint32_t _flags_save_string = ndr->flags;
10329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10330                         if (r->monitor_name) {
10331                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10332                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10333                         }
10334                         ndr->flags = _flags_save_string;
10335                 }
10336                 {
10337                         uint32_t _flags_save_string = ndr->flags;
10338                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10339                         if (r->default_datatype) {
10340                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10341                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10342                         }
10343                         ndr->flags = _flags_save_string;
10344                 }
10345         }
10346         return NDR_ERR_SUCCESS;
10347 }
10348
10349 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo3 *r)
10350 {
10351         uint32_t _ptr_driver_name;
10352         TALLOC_CTX *_mem_save_driver_name_0;
10353         uint32_t _ptr_architecture;
10354         TALLOC_CTX *_mem_save_architecture_0;
10355         uint32_t _ptr_driver_path;
10356         TALLOC_CTX *_mem_save_driver_path_0;
10357         uint32_t _ptr_data_file;
10358         TALLOC_CTX *_mem_save_data_file_0;
10359         uint32_t _ptr_config_file;
10360         TALLOC_CTX *_mem_save_config_file_0;
10361         uint32_t _ptr_help_file;
10362         TALLOC_CTX *_mem_save_help_file_0;
10363         uint32_t _ptr_dependent_files;
10364         TALLOC_CTX *_mem_save_dependent_files_0;
10365         uint32_t _ptr_monitor_name;
10366         TALLOC_CTX *_mem_save_monitor_name_0;
10367         uint32_t _ptr_default_datatype;
10368         TALLOC_CTX *_mem_save_default_datatype_0;
10369         if (ndr_flags & NDR_SCALARS) {
10370                 NDR_CHECK(ndr_pull_align(ndr, 4));
10371                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10372                 {
10373                         uint32_t _flags_save_string = ndr->flags;
10374                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10375                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10376                         if (_ptr_driver_name) {
10377                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10378                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10379                         } else {
10380                                 r->driver_name = NULL;
10381                         }
10382                         ndr->flags = _flags_save_string;
10383                 }
10384                 {
10385                         uint32_t _flags_save_string = ndr->flags;
10386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10387                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10388                         if (_ptr_architecture) {
10389                                 NDR_PULL_ALLOC(ndr, r->architecture);
10390                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10391                         } else {
10392                                 r->architecture = NULL;
10393                         }
10394                         ndr->flags = _flags_save_string;
10395                 }
10396                 {
10397                         uint32_t _flags_save_string = ndr->flags;
10398                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10399                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10400                         if (_ptr_driver_path) {
10401                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10402                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10403                         } else {
10404                                 r->driver_path = NULL;
10405                         }
10406                         ndr->flags = _flags_save_string;
10407                 }
10408                 {
10409                         uint32_t _flags_save_string = ndr->flags;
10410                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10411                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10412                         if (_ptr_data_file) {
10413                                 NDR_PULL_ALLOC(ndr, r->data_file);
10414                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10415                         } else {
10416                                 r->data_file = NULL;
10417                         }
10418                         ndr->flags = _flags_save_string;
10419                 }
10420                 {
10421                         uint32_t _flags_save_string = ndr->flags;
10422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10423                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10424                         if (_ptr_config_file) {
10425                                 NDR_PULL_ALLOC(ndr, r->config_file);
10426                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10427                         } else {
10428                                 r->config_file = NULL;
10429                         }
10430                         ndr->flags = _flags_save_string;
10431                 }
10432                 {
10433                         uint32_t _flags_save_string = ndr->flags;
10434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10435                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10436                         if (_ptr_help_file) {
10437                                 NDR_PULL_ALLOC(ndr, r->help_file);
10438                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10439                         } else {
10440                                 r->help_file = NULL;
10441                         }
10442                         ndr->flags = _flags_save_string;
10443                 }
10444                 {
10445                         uint32_t _flags_save_string_array = ndr->flags;
10446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10447                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10448                         if (_ptr_dependent_files) {
10449                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10450                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10451                         } else {
10452                                 r->dependent_files = NULL;
10453                         }
10454                         ndr->flags = _flags_save_string_array;
10455                 }
10456                 {
10457                         uint32_t _flags_save_string = ndr->flags;
10458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10459                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10460                         if (_ptr_monitor_name) {
10461                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10462                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10463                         } else {
10464                                 r->monitor_name = NULL;
10465                         }
10466                         ndr->flags = _flags_save_string;
10467                 }
10468                 {
10469                         uint32_t _flags_save_string = ndr->flags;
10470                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10471                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10472                         if (_ptr_default_datatype) {
10473                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10474                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10475                         } else {
10476                                 r->default_datatype = NULL;
10477                         }
10478                         ndr->flags = _flags_save_string;
10479                 }
10480         }
10481         if (ndr_flags & NDR_BUFFERS) {
10482                 {
10483                         uint32_t _flags_save_string = ndr->flags;
10484                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10485                         if (r->driver_name) {
10486                                 uint32_t _relative_save_offset;
10487                                 _relative_save_offset = ndr->offset;
10488                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
10489                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10490                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
10491                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
10492                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
10493                                 ndr->offset = _relative_save_offset;
10494                         }
10495                         ndr->flags = _flags_save_string;
10496                 }
10497                 {
10498                         uint32_t _flags_save_string = ndr->flags;
10499                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10500                         if (r->architecture) {
10501                                 uint32_t _relative_save_offset;
10502                                 _relative_save_offset = ndr->offset;
10503                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
10504                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
10505                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
10506                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
10507                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
10508                                 ndr->offset = _relative_save_offset;
10509                         }
10510                         ndr->flags = _flags_save_string;
10511                 }
10512                 {
10513                         uint32_t _flags_save_string = ndr->flags;
10514                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10515                         if (r->driver_path) {
10516                                 uint32_t _relative_save_offset;
10517                                 _relative_save_offset = ndr->offset;
10518                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
10519                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
10520                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
10521                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
10522                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
10523                                 ndr->offset = _relative_save_offset;
10524                         }
10525                         ndr->flags = _flags_save_string;
10526                 }
10527                 {
10528                         uint32_t _flags_save_string = ndr->flags;
10529                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10530                         if (r->data_file) {
10531                                 uint32_t _relative_save_offset;
10532                                 _relative_save_offset = ndr->offset;
10533                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
10534                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10535                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
10536                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
10537                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
10538                                 ndr->offset = _relative_save_offset;
10539                         }
10540                         ndr->flags = _flags_save_string;
10541                 }
10542                 {
10543                         uint32_t _flags_save_string = ndr->flags;
10544                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10545                         if (r->config_file) {
10546                                 uint32_t _relative_save_offset;
10547                                 _relative_save_offset = ndr->offset;
10548                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
10549                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10550                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
10551                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
10552                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
10553                                 ndr->offset = _relative_save_offset;
10554                         }
10555                         ndr->flags = _flags_save_string;
10556                 }
10557                 {
10558                         uint32_t _flags_save_string = ndr->flags;
10559                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10560                         if (r->help_file) {
10561                                 uint32_t _relative_save_offset;
10562                                 _relative_save_offset = ndr->offset;
10563                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
10564                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
10565                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
10566                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
10567                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
10568                                 ndr->offset = _relative_save_offset;
10569                         }
10570                         ndr->flags = _flags_save_string;
10571                 }
10572                 {
10573                         uint32_t _flags_save_string_array = ndr->flags;
10574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10575                         if (r->dependent_files) {
10576                                 uint32_t _relative_save_offset;
10577                                 _relative_save_offset = ndr->offset;
10578                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
10579                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
10580                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
10581                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
10582                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
10583                                 ndr->offset = _relative_save_offset;
10584                         }
10585                         ndr->flags = _flags_save_string_array;
10586                 }
10587                 {
10588                         uint32_t _flags_save_string = ndr->flags;
10589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10590                         if (r->monitor_name) {
10591                                 uint32_t _relative_save_offset;
10592                                 _relative_save_offset = ndr->offset;
10593                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
10594                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
10595                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
10596                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
10597                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
10598                                 ndr->offset = _relative_save_offset;
10599                         }
10600                         ndr->flags = _flags_save_string;
10601                 }
10602                 {
10603                         uint32_t _flags_save_string = ndr->flags;
10604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10605                         if (r->default_datatype) {
10606                                 uint32_t _relative_save_offset;
10607                                 _relative_save_offset = ndr->offset;
10608                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
10609                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
10610                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
10611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
10612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
10613                                 ndr->offset = _relative_save_offset;
10614                         }
10615                         ndr->flags = _flags_save_string;
10616                 }
10617         }
10618         return NDR_ERR_SUCCESS;
10619 }
10620
10621 _PUBLIC_ void ndr_print_spoolss_DriverInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo3 *r)
10622 {
10623         ndr_print_struct(ndr, name, "spoolss_DriverInfo3");
10624         ndr->depth++;
10625         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
10626         ndr_print_ptr(ndr, "driver_name", r->driver_name);
10627         ndr->depth++;
10628         if (r->driver_name) {
10629                 ndr_print_string(ndr, "driver_name", r->driver_name);
10630         }
10631         ndr->depth--;
10632         ndr_print_ptr(ndr, "architecture", r->architecture);
10633         ndr->depth++;
10634         if (r->architecture) {
10635                 ndr_print_string(ndr, "architecture", r->architecture);
10636         }
10637         ndr->depth--;
10638         ndr_print_ptr(ndr, "driver_path", r->driver_path);
10639         ndr->depth++;
10640         if (r->driver_path) {
10641                 ndr_print_string(ndr, "driver_path", r->driver_path);
10642         }
10643         ndr->depth--;
10644         ndr_print_ptr(ndr, "data_file", r->data_file);
10645         ndr->depth++;
10646         if (r->data_file) {
10647                 ndr_print_string(ndr, "data_file", r->data_file);
10648         }
10649         ndr->depth--;
10650         ndr_print_ptr(ndr, "config_file", r->config_file);
10651         ndr->depth++;
10652         if (r->config_file) {
10653                 ndr_print_string(ndr, "config_file", r->config_file);
10654         }
10655         ndr->depth--;
10656         ndr_print_ptr(ndr, "help_file", r->help_file);
10657         ndr->depth++;
10658         if (r->help_file) {
10659                 ndr_print_string(ndr, "help_file", r->help_file);
10660         }
10661         ndr->depth--;
10662         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
10663         ndr->depth++;
10664         if (r->dependent_files) {
10665                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
10666         }
10667         ndr->depth--;
10668         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
10669         ndr->depth++;
10670         if (r->monitor_name) {
10671                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
10672         }
10673         ndr->depth--;
10674         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
10675         ndr->depth++;
10676         if (r->default_datatype) {
10677                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
10678         }
10679         ndr->depth--;
10680         ndr->depth--;
10681 }
10682
10683 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo3(const struct spoolss_DriverInfo3 *r, struct smb_iconv_convenience *ic, int flags)
10684 {
10685         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo3, ic);
10686 }
10687
10688 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo4(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo4 *r)
10689 {
10690         if (ndr_flags & NDR_SCALARS) {
10691                 NDR_CHECK(ndr_push_align(ndr, 4));
10692                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
10693                 {
10694                         uint32_t _flags_save_string = ndr->flags;
10695                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10696                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
10697                         ndr->flags = _flags_save_string;
10698                 }
10699                 {
10700                         uint32_t _flags_save_string = ndr->flags;
10701                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10702                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
10703                         ndr->flags = _flags_save_string;
10704                 }
10705                 {
10706                         uint32_t _flags_save_string = ndr->flags;
10707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10708                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
10709                         ndr->flags = _flags_save_string;
10710                 }
10711                 {
10712                         uint32_t _flags_save_string = ndr->flags;
10713                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10714                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
10715                         ndr->flags = _flags_save_string;
10716                 }
10717                 {
10718                         uint32_t _flags_save_string = ndr->flags;
10719                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10720                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
10721                         ndr->flags = _flags_save_string;
10722                 }
10723                 {
10724                         uint32_t _flags_save_string = ndr->flags;
10725                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10726                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
10727                         ndr->flags = _flags_save_string;
10728                 }
10729                 {
10730                         uint32_t _flags_save_string_array = ndr->flags;
10731                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10732                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
10733                         ndr->flags = _flags_save_string_array;
10734                 }
10735                 {
10736                         uint32_t _flags_save_string = ndr->flags;
10737                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10738                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
10739                         ndr->flags = _flags_save_string;
10740                 }
10741                 {
10742                         uint32_t _flags_save_string = ndr->flags;
10743                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10744                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
10745                         ndr->flags = _flags_save_string;
10746                 }
10747                 {
10748                         uint32_t _flags_save_string_array = ndr->flags;
10749                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10750                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
10751                         ndr->flags = _flags_save_string_array;
10752                 }
10753         }
10754         if (ndr_flags & NDR_BUFFERS) {
10755                 {
10756                         uint32_t _flags_save_string = ndr->flags;
10757                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10758                         if (r->driver_name) {
10759                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
10760                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
10761                         }
10762                         ndr->flags = _flags_save_string;
10763                 }
10764                 {
10765                         uint32_t _flags_save_string = ndr->flags;
10766                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10767                         if (r->architecture) {
10768                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
10769                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
10770                         }
10771                         ndr->flags = _flags_save_string;
10772                 }
10773                 {
10774                         uint32_t _flags_save_string = ndr->flags;
10775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10776                         if (r->driver_path) {
10777                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
10778                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
10779                         }
10780                         ndr->flags = _flags_save_string;
10781                 }
10782                 {
10783                         uint32_t _flags_save_string = ndr->flags;
10784                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10785                         if (r->data_file) {
10786                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
10787                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
10788                         }
10789                         ndr->flags = _flags_save_string;
10790                 }
10791                 {
10792                         uint32_t _flags_save_string = ndr->flags;
10793                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10794                         if (r->config_file) {
10795                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
10796                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
10797                         }
10798                         ndr->flags = _flags_save_string;
10799                 }
10800                 {
10801                         uint32_t _flags_save_string = ndr->flags;
10802                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10803                         if (r->help_file) {
10804                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
10805                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
10806                         }
10807                         ndr->flags = _flags_save_string;
10808                 }
10809                 {
10810                         uint32_t _flags_save_string_array = ndr->flags;
10811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10812                         if (r->dependent_files) {
10813                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
10814                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
10815                         }
10816                         ndr->flags = _flags_save_string_array;
10817                 }
10818                 {
10819                         uint32_t _flags_save_string = ndr->flags;
10820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10821                         if (r->monitor_name) {
10822                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
10823                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
10824                         }
10825                         ndr->flags = _flags_save_string;
10826                 }
10827                 {
10828                         uint32_t _flags_save_string = ndr->flags;
10829                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10830                         if (r->default_datatype) {
10831                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
10832                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
10833                         }
10834                         ndr->flags = _flags_save_string;
10835                 }
10836                 {
10837                         uint32_t _flags_save_string_array = ndr->flags;
10838                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10839                         if (r->previous_names) {
10840                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
10841                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
10842                         }
10843                         ndr->flags = _flags_save_string_array;
10844                 }
10845         }
10846         return NDR_ERR_SUCCESS;
10847 }
10848
10849 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo4(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo4 *r)
10850 {
10851         uint32_t _ptr_driver_name;
10852         TALLOC_CTX *_mem_save_driver_name_0;
10853         uint32_t _ptr_architecture;
10854         TALLOC_CTX *_mem_save_architecture_0;
10855         uint32_t _ptr_driver_path;
10856         TALLOC_CTX *_mem_save_driver_path_0;
10857         uint32_t _ptr_data_file;
10858         TALLOC_CTX *_mem_save_data_file_0;
10859         uint32_t _ptr_config_file;
10860         TALLOC_CTX *_mem_save_config_file_0;
10861         uint32_t _ptr_help_file;
10862         TALLOC_CTX *_mem_save_help_file_0;
10863         uint32_t _ptr_dependent_files;
10864         TALLOC_CTX *_mem_save_dependent_files_0;
10865         uint32_t _ptr_monitor_name;
10866         TALLOC_CTX *_mem_save_monitor_name_0;
10867         uint32_t _ptr_default_datatype;
10868         TALLOC_CTX *_mem_save_default_datatype_0;
10869         uint32_t _ptr_previous_names;
10870         TALLOC_CTX *_mem_save_previous_names_0;
10871         if (ndr_flags & NDR_SCALARS) {
10872                 NDR_CHECK(ndr_pull_align(ndr, 4));
10873                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
10874                 {
10875                         uint32_t _flags_save_string = ndr->flags;
10876                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10877                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
10878                         if (_ptr_driver_name) {
10879                                 NDR_PULL_ALLOC(ndr, r->driver_name);
10880                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
10881                         } else {
10882                                 r->driver_name = NULL;
10883                         }
10884                         ndr->flags = _flags_save_string;
10885                 }
10886                 {
10887                         uint32_t _flags_save_string = ndr->flags;
10888                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10889                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
10890                         if (_ptr_architecture) {
10891                                 NDR_PULL_ALLOC(ndr, r->architecture);
10892                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
10893                         } else {
10894                                 r->architecture = NULL;
10895                         }
10896                         ndr->flags = _flags_save_string;
10897                 }
10898                 {
10899                         uint32_t _flags_save_string = ndr->flags;
10900                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10901                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
10902                         if (_ptr_driver_path) {
10903                                 NDR_PULL_ALLOC(ndr, r->driver_path);
10904                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
10905                         } else {
10906                                 r->driver_path = NULL;
10907                         }
10908                         ndr->flags = _flags_save_string;
10909                 }
10910                 {
10911                         uint32_t _flags_save_string = ndr->flags;
10912                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10913                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
10914                         if (_ptr_data_file) {
10915                                 NDR_PULL_ALLOC(ndr, r->data_file);
10916                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
10917                         } else {
10918                                 r->data_file = NULL;
10919                         }
10920                         ndr->flags = _flags_save_string;
10921                 }
10922                 {
10923                         uint32_t _flags_save_string = ndr->flags;
10924                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10925                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
10926                         if (_ptr_config_file) {
10927                                 NDR_PULL_ALLOC(ndr, r->config_file);
10928                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
10929                         } else {
10930                                 r->config_file = NULL;
10931                         }
10932                         ndr->flags = _flags_save_string;
10933                 }
10934                 {
10935                         uint32_t _flags_save_string = ndr->flags;
10936                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10937                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
10938                         if (_ptr_help_file) {
10939                                 NDR_PULL_ALLOC(ndr, r->help_file);
10940                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
10941                         } else {
10942                                 r->help_file = NULL;
10943                         }
10944                         ndr->flags = _flags_save_string;
10945                 }
10946                 {
10947                         uint32_t _flags_save_string_array = ndr->flags;
10948                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10949                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
10950                         if (_ptr_dependent_files) {
10951                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
10952                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
10953                         } else {
10954                                 r->dependent_files = NULL;
10955                         }
10956                         ndr->flags = _flags_save_string_array;
10957                 }
10958                 {
10959                         uint32_t _flags_save_string = ndr->flags;
10960                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10961                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
10962                         if (_ptr_monitor_name) {
10963                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
10964                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
10965                         } else {
10966                                 r->monitor_name = NULL;
10967                         }
10968                         ndr->flags = _flags_save_string;
10969                 }
10970                 {
10971                         uint32_t _flags_save_string = ndr->flags;
10972                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10973                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
10974                         if (_ptr_default_datatype) {
10975                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
10976                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
10977                         } else {
10978                                 r->default_datatype = NULL;
10979                         }
10980                         ndr->flags = _flags_save_string;
10981                 }
10982                 {
10983                         uint32_t _flags_save_string_array = ndr->flags;
10984                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10985                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
10986                         if (_ptr_previous_names) {
10987                                 NDR_PULL_ALLOC(ndr, r->previous_names);
10988                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
10989                         } else {
10990                                 r->previous_names = NULL;
10991                         }
10992                         ndr->flags = _flags_save_string_array;
10993                 }
10994         }
10995         if (ndr_flags & NDR_BUFFERS) {
10996                 {
10997                         uint32_t _flags_save_string = ndr->flags;
10998                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
10999                         if (r->driver_name) {
11000                                 uint32_t _relative_save_offset;
11001                                 _relative_save_offset = ndr->offset;
11002                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11003                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11004                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11005                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11006                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11007                                 ndr->offset = _relative_save_offset;
11008                         }
11009                         ndr->flags = _flags_save_string;
11010                 }
11011                 {
11012                         uint32_t _flags_save_string = ndr->flags;
11013                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11014                         if (r->architecture) {
11015                                 uint32_t _relative_save_offset;
11016                                 _relative_save_offset = ndr->offset;
11017                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11018                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11019                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11020                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11021                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11022                                 ndr->offset = _relative_save_offset;
11023                         }
11024                         ndr->flags = _flags_save_string;
11025                 }
11026                 {
11027                         uint32_t _flags_save_string = ndr->flags;
11028                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11029                         if (r->driver_path) {
11030                                 uint32_t _relative_save_offset;
11031                                 _relative_save_offset = ndr->offset;
11032                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11033                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11034                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11035                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11036                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11037                                 ndr->offset = _relative_save_offset;
11038                         }
11039                         ndr->flags = _flags_save_string;
11040                 }
11041                 {
11042                         uint32_t _flags_save_string = ndr->flags;
11043                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11044                         if (r->data_file) {
11045                                 uint32_t _relative_save_offset;
11046                                 _relative_save_offset = ndr->offset;
11047                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11048                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11049                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11050                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11051                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11052                                 ndr->offset = _relative_save_offset;
11053                         }
11054                         ndr->flags = _flags_save_string;
11055                 }
11056                 {
11057                         uint32_t _flags_save_string = ndr->flags;
11058                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11059                         if (r->config_file) {
11060                                 uint32_t _relative_save_offset;
11061                                 _relative_save_offset = ndr->offset;
11062                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11063                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11064                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11065                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11066                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11067                                 ndr->offset = _relative_save_offset;
11068                         }
11069                         ndr->flags = _flags_save_string;
11070                 }
11071                 {
11072                         uint32_t _flags_save_string = ndr->flags;
11073                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11074                         if (r->help_file) {
11075                                 uint32_t _relative_save_offset;
11076                                 _relative_save_offset = ndr->offset;
11077                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
11078                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11079                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
11080                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
11081                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
11082                                 ndr->offset = _relative_save_offset;
11083                         }
11084                         ndr->flags = _flags_save_string;
11085                 }
11086                 {
11087                         uint32_t _flags_save_string_array = ndr->flags;
11088                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11089                         if (r->dependent_files) {
11090                                 uint32_t _relative_save_offset;
11091                                 _relative_save_offset = ndr->offset;
11092                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
11093                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
11094                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
11095                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
11096                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
11097                                 ndr->offset = _relative_save_offset;
11098                         }
11099                         ndr->flags = _flags_save_string_array;
11100                 }
11101                 {
11102                         uint32_t _flags_save_string = ndr->flags;
11103                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11104                         if (r->monitor_name) {
11105                                 uint32_t _relative_save_offset;
11106                                 _relative_save_offset = ndr->offset;
11107                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
11108                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11109                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
11110                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
11111                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
11112                                 ndr->offset = _relative_save_offset;
11113                         }
11114                         ndr->flags = _flags_save_string;
11115                 }
11116                 {
11117                         uint32_t _flags_save_string = ndr->flags;
11118                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11119                         if (r->default_datatype) {
11120                                 uint32_t _relative_save_offset;
11121                                 _relative_save_offset = ndr->offset;
11122                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
11123                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
11124                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
11125                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
11126                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
11127                                 ndr->offset = _relative_save_offset;
11128                         }
11129                         ndr->flags = _flags_save_string;
11130                 }
11131                 {
11132                         uint32_t _flags_save_string_array = ndr->flags;
11133                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11134                         if (r->previous_names) {
11135                                 uint32_t _relative_save_offset;
11136                                 _relative_save_offset = ndr->offset;
11137                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
11138                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
11139                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
11140                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
11141                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
11142                                 ndr->offset = _relative_save_offset;
11143                         }
11144                         ndr->flags = _flags_save_string_array;
11145                 }
11146         }
11147         return NDR_ERR_SUCCESS;
11148 }
11149
11150 _PUBLIC_ void ndr_print_spoolss_DriverInfo4(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo4 *r)
11151 {
11152         ndr_print_struct(ndr, name, "spoolss_DriverInfo4");
11153         ndr->depth++;
11154         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11155         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11156         ndr->depth++;
11157         if (r->driver_name) {
11158                 ndr_print_string(ndr, "driver_name", r->driver_name);
11159         }
11160         ndr->depth--;
11161         ndr_print_ptr(ndr, "architecture", r->architecture);
11162         ndr->depth++;
11163         if (r->architecture) {
11164                 ndr_print_string(ndr, "architecture", r->architecture);
11165         }
11166         ndr->depth--;
11167         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11168         ndr->depth++;
11169         if (r->driver_path) {
11170                 ndr_print_string(ndr, "driver_path", r->driver_path);
11171         }
11172         ndr->depth--;
11173         ndr_print_ptr(ndr, "data_file", r->data_file);
11174         ndr->depth++;
11175         if (r->data_file) {
11176                 ndr_print_string(ndr, "data_file", r->data_file);
11177         }
11178         ndr->depth--;
11179         ndr_print_ptr(ndr, "config_file", r->config_file);
11180         ndr->depth++;
11181         if (r->config_file) {
11182                 ndr_print_string(ndr, "config_file", r->config_file);
11183         }
11184         ndr->depth--;
11185         ndr_print_ptr(ndr, "help_file", r->help_file);
11186         ndr->depth++;
11187         if (r->help_file) {
11188                 ndr_print_string(ndr, "help_file", r->help_file);
11189         }
11190         ndr->depth--;
11191         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
11192         ndr->depth++;
11193         if (r->dependent_files) {
11194                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
11195         }
11196         ndr->depth--;
11197         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
11198         ndr->depth++;
11199         if (r->monitor_name) {
11200                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
11201         }
11202         ndr->depth--;
11203         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
11204         ndr->depth++;
11205         if (r->default_datatype) {
11206                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
11207         }
11208         ndr->depth--;
11209         ndr_print_ptr(ndr, "previous_names", r->previous_names);
11210         ndr->depth++;
11211         if (r->previous_names) {
11212                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
11213         }
11214         ndr->depth--;
11215         ndr->depth--;
11216 }
11217
11218 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo4(const struct spoolss_DriverInfo4 *r, struct smb_iconv_convenience *ic, int flags)
11219 {
11220         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo4, ic);
11221 }
11222
11223 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo5(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo5 *r)
11224 {
11225         if (ndr_flags & NDR_SCALARS) {
11226                 NDR_CHECK(ndr_push_align(ndr, 4));
11227                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11228                 {
11229                         uint32_t _flags_save_string = ndr->flags;
11230                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11231                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11232                         ndr->flags = _flags_save_string;
11233                 }
11234                 {
11235                         uint32_t _flags_save_string = ndr->flags;
11236                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11237                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11238                         ndr->flags = _flags_save_string;
11239                 }
11240                 {
11241                         uint32_t _flags_save_string = ndr->flags;
11242                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11243                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11244                         ndr->flags = _flags_save_string;
11245                 }
11246                 {
11247                         uint32_t _flags_save_string = ndr->flags;
11248                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11249                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11250                         ndr->flags = _flags_save_string;
11251                 }
11252                 {
11253                         uint32_t _flags_save_string = ndr->flags;
11254                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11255                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11256                         ndr->flags = _flags_save_string;
11257                 }
11258                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_attributes));
11259                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->config_version));
11260                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->driver_version));
11261         }
11262         if (ndr_flags & NDR_BUFFERS) {
11263                 {
11264                         uint32_t _flags_save_string = ndr->flags;
11265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11266                         if (r->driver_name) {
11267                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11268                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11269                         }
11270                         ndr->flags = _flags_save_string;
11271                 }
11272                 {
11273                         uint32_t _flags_save_string = ndr->flags;
11274                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11275                         if (r->architecture) {
11276                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11277                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11278                         }
11279                         ndr->flags = _flags_save_string;
11280                 }
11281                 {
11282                         uint32_t _flags_save_string = ndr->flags;
11283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11284                         if (r->driver_path) {
11285                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11286                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11287                         }
11288                         ndr->flags = _flags_save_string;
11289                 }
11290                 {
11291                         uint32_t _flags_save_string = ndr->flags;
11292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11293                         if (r->data_file) {
11294                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11295                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11296                         }
11297                         ndr->flags = _flags_save_string;
11298                 }
11299                 {
11300                         uint32_t _flags_save_string = ndr->flags;
11301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11302                         if (r->config_file) {
11303                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11304                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11305                         }
11306                         ndr->flags = _flags_save_string;
11307                 }
11308         }
11309         return NDR_ERR_SUCCESS;
11310 }
11311
11312 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo5(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo5 *r)
11313 {
11314         uint32_t _ptr_driver_name;
11315         TALLOC_CTX *_mem_save_driver_name_0;
11316         uint32_t _ptr_architecture;
11317         TALLOC_CTX *_mem_save_architecture_0;
11318         uint32_t _ptr_driver_path;
11319         TALLOC_CTX *_mem_save_driver_path_0;
11320         uint32_t _ptr_data_file;
11321         TALLOC_CTX *_mem_save_data_file_0;
11322         uint32_t _ptr_config_file;
11323         TALLOC_CTX *_mem_save_config_file_0;
11324         if (ndr_flags & NDR_SCALARS) {
11325                 NDR_CHECK(ndr_pull_align(ndr, 4));
11326                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11327                 {
11328                         uint32_t _flags_save_string = ndr->flags;
11329                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11330                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11331                         if (_ptr_driver_name) {
11332                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11333                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11334                         } else {
11335                                 r->driver_name = NULL;
11336                         }
11337                         ndr->flags = _flags_save_string;
11338                 }
11339                 {
11340                         uint32_t _flags_save_string = ndr->flags;
11341                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11342                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11343                         if (_ptr_architecture) {
11344                                 NDR_PULL_ALLOC(ndr, r->architecture);
11345                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11346                         } else {
11347                                 r->architecture = NULL;
11348                         }
11349                         ndr->flags = _flags_save_string;
11350                 }
11351                 {
11352                         uint32_t _flags_save_string = ndr->flags;
11353                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11354                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11355                         if (_ptr_driver_path) {
11356                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11357                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11358                         } else {
11359                                 r->driver_path = NULL;
11360                         }
11361                         ndr->flags = _flags_save_string;
11362                 }
11363                 {
11364                         uint32_t _flags_save_string = ndr->flags;
11365                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11366                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11367                         if (_ptr_data_file) {
11368                                 NDR_PULL_ALLOC(ndr, r->data_file);
11369                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11370                         } else {
11371                                 r->data_file = NULL;
11372                         }
11373                         ndr->flags = _flags_save_string;
11374                 }
11375                 {
11376                         uint32_t _flags_save_string = ndr->flags;
11377                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11378                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11379                         if (_ptr_config_file) {
11380                                 NDR_PULL_ALLOC(ndr, r->config_file);
11381                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11382                         } else {
11383                                 r->config_file = NULL;
11384                         }
11385                         ndr->flags = _flags_save_string;
11386                 }
11387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_attributes));
11388                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->config_version));
11389                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->driver_version));
11390         }
11391         if (ndr_flags & NDR_BUFFERS) {
11392                 {
11393                         uint32_t _flags_save_string = ndr->flags;
11394                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11395                         if (r->driver_name) {
11396                                 uint32_t _relative_save_offset;
11397                                 _relative_save_offset = ndr->offset;
11398                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11399                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11400                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11401                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11402                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11403                                 ndr->offset = _relative_save_offset;
11404                         }
11405                         ndr->flags = _flags_save_string;
11406                 }
11407                 {
11408                         uint32_t _flags_save_string = ndr->flags;
11409                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11410                         if (r->architecture) {
11411                                 uint32_t _relative_save_offset;
11412                                 _relative_save_offset = ndr->offset;
11413                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11414                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11415                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11416                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11417                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11418                                 ndr->offset = _relative_save_offset;
11419                         }
11420                         ndr->flags = _flags_save_string;
11421                 }
11422                 {
11423                         uint32_t _flags_save_string = ndr->flags;
11424                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11425                         if (r->driver_path) {
11426                                 uint32_t _relative_save_offset;
11427                                 _relative_save_offset = ndr->offset;
11428                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11429                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11430                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11431                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11432                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11433                                 ndr->offset = _relative_save_offset;
11434                         }
11435                         ndr->flags = _flags_save_string;
11436                 }
11437                 {
11438                         uint32_t _flags_save_string = ndr->flags;
11439                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11440                         if (r->data_file) {
11441                                 uint32_t _relative_save_offset;
11442                                 _relative_save_offset = ndr->offset;
11443                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11444                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11445                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11446                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
11447                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
11448                                 ndr->offset = _relative_save_offset;
11449                         }
11450                         ndr->flags = _flags_save_string;
11451                 }
11452                 {
11453                         uint32_t _flags_save_string = ndr->flags;
11454                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11455                         if (r->config_file) {
11456                                 uint32_t _relative_save_offset;
11457                                 _relative_save_offset = ndr->offset;
11458                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
11459                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11460                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
11461                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
11462                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
11463                                 ndr->offset = _relative_save_offset;
11464                         }
11465                         ndr->flags = _flags_save_string;
11466                 }
11467         }
11468         return NDR_ERR_SUCCESS;
11469 }
11470
11471 _PUBLIC_ void ndr_print_spoolss_DriverInfo5(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo5 *r)
11472 {
11473         ndr_print_struct(ndr, name, "spoolss_DriverInfo5");
11474         ndr->depth++;
11475         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
11476         ndr_print_ptr(ndr, "driver_name", r->driver_name);
11477         ndr->depth++;
11478         if (r->driver_name) {
11479                 ndr_print_string(ndr, "driver_name", r->driver_name);
11480         }
11481         ndr->depth--;
11482         ndr_print_ptr(ndr, "architecture", r->architecture);
11483         ndr->depth++;
11484         if (r->architecture) {
11485                 ndr_print_string(ndr, "architecture", r->architecture);
11486         }
11487         ndr->depth--;
11488         ndr_print_ptr(ndr, "driver_path", r->driver_path);
11489         ndr->depth++;
11490         if (r->driver_path) {
11491                 ndr_print_string(ndr, "driver_path", r->driver_path);
11492         }
11493         ndr->depth--;
11494         ndr_print_ptr(ndr, "data_file", r->data_file);
11495         ndr->depth++;
11496         if (r->data_file) {
11497                 ndr_print_string(ndr, "data_file", r->data_file);
11498         }
11499         ndr->depth--;
11500         ndr_print_ptr(ndr, "config_file", r->config_file);
11501         ndr->depth++;
11502         if (r->config_file) {
11503                 ndr_print_string(ndr, "config_file", r->config_file);
11504         }
11505         ndr->depth--;
11506         ndr_print_uint32(ndr, "driver_attributes", r->driver_attributes);
11507         ndr_print_uint32(ndr, "config_version", r->config_version);
11508         ndr_print_uint32(ndr, "driver_version", r->driver_version);
11509         ndr->depth--;
11510 }
11511
11512 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo5(const struct spoolss_DriverInfo5 *r, struct smb_iconv_convenience *ic, int flags)
11513 {
11514         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo5, ic);
11515 }
11516
11517 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo6(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo6 *r)
11518 {
11519         if (ndr_flags & NDR_SCALARS) {
11520                 NDR_CHECK(ndr_push_align(ndr, 8));
11521                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
11522                 {
11523                         uint32_t _flags_save_string = ndr->flags;
11524                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11525                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
11526                         ndr->flags = _flags_save_string;
11527                 }
11528                 {
11529                         uint32_t _flags_save_string = ndr->flags;
11530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11531                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
11532                         ndr->flags = _flags_save_string;
11533                 }
11534                 {
11535                         uint32_t _flags_save_string = ndr->flags;
11536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11537                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
11538                         ndr->flags = _flags_save_string;
11539                 }
11540                 {
11541                         uint32_t _flags_save_string = ndr->flags;
11542                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11543                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
11544                         ndr->flags = _flags_save_string;
11545                 }
11546                 {
11547                         uint32_t _flags_save_string = ndr->flags;
11548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11549                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
11550                         ndr->flags = _flags_save_string;
11551                 }
11552                 {
11553                         uint32_t _flags_save_string = ndr->flags;
11554                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11555                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
11556                         ndr->flags = _flags_save_string;
11557                 }
11558                 {
11559                         uint32_t _flags_save_string_array = ndr->flags;
11560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11561                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
11562                         ndr->flags = _flags_save_string_array;
11563                 }
11564                 {
11565                         uint32_t _flags_save_string = ndr->flags;
11566                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11567                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
11568                         ndr->flags = _flags_save_string;
11569                 }
11570                 {
11571                         uint32_t _flags_save_string = ndr->flags;
11572                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11573                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
11574                         ndr->flags = _flags_save_string;
11575                 }
11576                 {
11577                         uint32_t _flags_save_string_array = ndr->flags;
11578                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11579                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
11580                         ndr->flags = _flags_save_string_array;
11581                 }
11582                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
11583                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
11584                 {
11585                         uint32_t _flags_save_string = ndr->flags;
11586                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11587                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
11588                         ndr->flags = _flags_save_string;
11589                 }
11590                 {
11591                         uint32_t _flags_save_string = ndr->flags;
11592                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11593                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
11594                         ndr->flags = _flags_save_string;
11595                 }
11596                 {
11597                         uint32_t _flags_save_string = ndr->flags;
11598                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11599                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
11600                         ndr->flags = _flags_save_string;
11601                 }
11602                 {
11603                         uint32_t _flags_save_string = ndr->flags;
11604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11605                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
11606                         ndr->flags = _flags_save_string;
11607                 }
11608         }
11609         if (ndr_flags & NDR_BUFFERS) {
11610                 {
11611                         uint32_t _flags_save_string = ndr->flags;
11612                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11613                         if (r->driver_name) {
11614                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
11615                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
11616                         }
11617                         ndr->flags = _flags_save_string;
11618                 }
11619                 {
11620                         uint32_t _flags_save_string = ndr->flags;
11621                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11622                         if (r->architecture) {
11623                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
11624                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
11625                         }
11626                         ndr->flags = _flags_save_string;
11627                 }
11628                 {
11629                         uint32_t _flags_save_string = ndr->flags;
11630                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11631                         if (r->driver_path) {
11632                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
11633                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
11634                         }
11635                         ndr->flags = _flags_save_string;
11636                 }
11637                 {
11638                         uint32_t _flags_save_string = ndr->flags;
11639                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11640                         if (r->data_file) {
11641                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
11642                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
11643                         }
11644                         ndr->flags = _flags_save_string;
11645                 }
11646                 {
11647                         uint32_t _flags_save_string = ndr->flags;
11648                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11649                         if (r->config_file) {
11650                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
11651                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
11652                         }
11653                         ndr->flags = _flags_save_string;
11654                 }
11655                 {
11656                         uint32_t _flags_save_string = ndr->flags;
11657                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11658                         if (r->help_file) {
11659                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
11660                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
11661                         }
11662                         ndr->flags = _flags_save_string;
11663                 }
11664                 {
11665                         uint32_t _flags_save_string_array = ndr->flags;
11666                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11667                         if (r->dependent_files) {
11668                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
11669                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
11670                         }
11671                         ndr->flags = _flags_save_string_array;
11672                 }
11673                 {
11674                         uint32_t _flags_save_string = ndr->flags;
11675                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11676                         if (r->monitor_name) {
11677                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
11678                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
11679                         }
11680                         ndr->flags = _flags_save_string;
11681                 }
11682                 {
11683                         uint32_t _flags_save_string = ndr->flags;
11684                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11685                         if (r->default_datatype) {
11686                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
11687                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
11688                         }
11689                         ndr->flags = _flags_save_string;
11690                 }
11691                 {
11692                         uint32_t _flags_save_string_array = ndr->flags;
11693                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11694                         if (r->previous_names) {
11695                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
11696                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
11697                         }
11698                         ndr->flags = _flags_save_string_array;
11699                 }
11700                 {
11701                         uint32_t _flags_save_string = ndr->flags;
11702                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11703                         if (r->manufacturer_name) {
11704                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
11705                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
11706                         }
11707                         ndr->flags = _flags_save_string;
11708                 }
11709                 {
11710                         uint32_t _flags_save_string = ndr->flags;
11711                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11712                         if (r->manufacturer_url) {
11713                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
11714                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
11715                         }
11716                         ndr->flags = _flags_save_string;
11717                 }
11718                 {
11719                         uint32_t _flags_save_string = ndr->flags;
11720                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11721                         if (r->hardware_id) {
11722                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
11723                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
11724                         }
11725                         ndr->flags = _flags_save_string;
11726                 }
11727                 {
11728                         uint32_t _flags_save_string = ndr->flags;
11729                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11730                         if (r->provider) {
11731                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
11732                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
11733                         }
11734                         ndr->flags = _flags_save_string;
11735                 }
11736         }
11737         return NDR_ERR_SUCCESS;
11738 }
11739
11740 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo6(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo6 *r)
11741 {
11742         uint32_t _ptr_driver_name;
11743         TALLOC_CTX *_mem_save_driver_name_0;
11744         uint32_t _ptr_architecture;
11745         TALLOC_CTX *_mem_save_architecture_0;
11746         uint32_t _ptr_driver_path;
11747         TALLOC_CTX *_mem_save_driver_path_0;
11748         uint32_t _ptr_data_file;
11749         TALLOC_CTX *_mem_save_data_file_0;
11750         uint32_t _ptr_config_file;
11751         TALLOC_CTX *_mem_save_config_file_0;
11752         uint32_t _ptr_help_file;
11753         TALLOC_CTX *_mem_save_help_file_0;
11754         uint32_t _ptr_dependent_files;
11755         TALLOC_CTX *_mem_save_dependent_files_0;
11756         uint32_t _ptr_monitor_name;
11757         TALLOC_CTX *_mem_save_monitor_name_0;
11758         uint32_t _ptr_default_datatype;
11759         TALLOC_CTX *_mem_save_default_datatype_0;
11760         uint32_t _ptr_previous_names;
11761         TALLOC_CTX *_mem_save_previous_names_0;
11762         uint32_t _ptr_manufacturer_name;
11763         TALLOC_CTX *_mem_save_manufacturer_name_0;
11764         uint32_t _ptr_manufacturer_url;
11765         TALLOC_CTX *_mem_save_manufacturer_url_0;
11766         uint32_t _ptr_hardware_id;
11767         TALLOC_CTX *_mem_save_hardware_id_0;
11768         uint32_t _ptr_provider;
11769         TALLOC_CTX *_mem_save_provider_0;
11770         if (ndr_flags & NDR_SCALARS) {
11771                 NDR_CHECK(ndr_pull_align(ndr, 8));
11772                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
11773                 {
11774                         uint32_t _flags_save_string = ndr->flags;
11775                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11776                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
11777                         if (_ptr_driver_name) {
11778                                 NDR_PULL_ALLOC(ndr, r->driver_name);
11779                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
11780                         } else {
11781                                 r->driver_name = NULL;
11782                         }
11783                         ndr->flags = _flags_save_string;
11784                 }
11785                 {
11786                         uint32_t _flags_save_string = ndr->flags;
11787                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11788                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
11789                         if (_ptr_architecture) {
11790                                 NDR_PULL_ALLOC(ndr, r->architecture);
11791                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
11792                         } else {
11793                                 r->architecture = NULL;
11794                         }
11795                         ndr->flags = _flags_save_string;
11796                 }
11797                 {
11798                         uint32_t _flags_save_string = ndr->flags;
11799                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11800                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
11801                         if (_ptr_driver_path) {
11802                                 NDR_PULL_ALLOC(ndr, r->driver_path);
11803                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
11804                         } else {
11805                                 r->driver_path = NULL;
11806                         }
11807                         ndr->flags = _flags_save_string;
11808                 }
11809                 {
11810                         uint32_t _flags_save_string = ndr->flags;
11811                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11812                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
11813                         if (_ptr_data_file) {
11814                                 NDR_PULL_ALLOC(ndr, r->data_file);
11815                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
11816                         } else {
11817                                 r->data_file = NULL;
11818                         }
11819                         ndr->flags = _flags_save_string;
11820                 }
11821                 {
11822                         uint32_t _flags_save_string = ndr->flags;
11823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11824                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
11825                         if (_ptr_config_file) {
11826                                 NDR_PULL_ALLOC(ndr, r->config_file);
11827                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
11828                         } else {
11829                                 r->config_file = NULL;
11830                         }
11831                         ndr->flags = _flags_save_string;
11832                 }
11833                 {
11834                         uint32_t _flags_save_string = ndr->flags;
11835                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11836                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
11837                         if (_ptr_help_file) {
11838                                 NDR_PULL_ALLOC(ndr, r->help_file);
11839                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
11840                         } else {
11841                                 r->help_file = NULL;
11842                         }
11843                         ndr->flags = _flags_save_string;
11844                 }
11845                 {
11846                         uint32_t _flags_save_string_array = ndr->flags;
11847                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11848                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
11849                         if (_ptr_dependent_files) {
11850                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
11851                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
11852                         } else {
11853                                 r->dependent_files = NULL;
11854                         }
11855                         ndr->flags = _flags_save_string_array;
11856                 }
11857                 {
11858                         uint32_t _flags_save_string = ndr->flags;
11859                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11860                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
11861                         if (_ptr_monitor_name) {
11862                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
11863                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
11864                         } else {
11865                                 r->monitor_name = NULL;
11866                         }
11867                         ndr->flags = _flags_save_string;
11868                 }
11869                 {
11870                         uint32_t _flags_save_string = ndr->flags;
11871                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11872                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
11873                         if (_ptr_default_datatype) {
11874                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
11875                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
11876                         } else {
11877                                 r->default_datatype = NULL;
11878                         }
11879                         ndr->flags = _flags_save_string;
11880                 }
11881                 {
11882                         uint32_t _flags_save_string_array = ndr->flags;
11883                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11884                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
11885                         if (_ptr_previous_names) {
11886                                 NDR_PULL_ALLOC(ndr, r->previous_names);
11887                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
11888                         } else {
11889                                 r->previous_names = NULL;
11890                         }
11891                         ndr->flags = _flags_save_string_array;
11892                 }
11893                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
11894                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
11895                 {
11896                         uint32_t _flags_save_string = ndr->flags;
11897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11898                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
11899                         if (_ptr_manufacturer_name) {
11900                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
11901                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
11902                         } else {
11903                                 r->manufacturer_name = NULL;
11904                         }
11905                         ndr->flags = _flags_save_string;
11906                 }
11907                 {
11908                         uint32_t _flags_save_string = ndr->flags;
11909                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11910                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
11911                         if (_ptr_manufacturer_url) {
11912                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
11913                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
11914                         } else {
11915                                 r->manufacturer_url = NULL;
11916                         }
11917                         ndr->flags = _flags_save_string;
11918                 }
11919                 {
11920                         uint32_t _flags_save_string = ndr->flags;
11921                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11922                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
11923                         if (_ptr_hardware_id) {
11924                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
11925                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
11926                         } else {
11927                                 r->hardware_id = NULL;
11928                         }
11929                         ndr->flags = _flags_save_string;
11930                 }
11931                 {
11932                         uint32_t _flags_save_string = ndr->flags;
11933                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11934                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
11935                         if (_ptr_provider) {
11936                                 NDR_PULL_ALLOC(ndr, r->provider);
11937                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
11938                         } else {
11939                                 r->provider = NULL;
11940                         }
11941                         ndr->flags = _flags_save_string;
11942                 }
11943         }
11944         if (ndr_flags & NDR_BUFFERS) {
11945                 {
11946                         uint32_t _flags_save_string = ndr->flags;
11947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11948                         if (r->driver_name) {
11949                                 uint32_t _relative_save_offset;
11950                                 _relative_save_offset = ndr->offset;
11951                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
11952                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
11953                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
11954                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
11955                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
11956                                 ndr->offset = _relative_save_offset;
11957                         }
11958                         ndr->flags = _flags_save_string;
11959                 }
11960                 {
11961                         uint32_t _flags_save_string = ndr->flags;
11962                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11963                         if (r->architecture) {
11964                                 uint32_t _relative_save_offset;
11965                                 _relative_save_offset = ndr->offset;
11966                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
11967                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
11968                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
11969                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
11970                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
11971                                 ndr->offset = _relative_save_offset;
11972                         }
11973                         ndr->flags = _flags_save_string;
11974                 }
11975                 {
11976                         uint32_t _flags_save_string = ndr->flags;
11977                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11978                         if (r->driver_path) {
11979                                 uint32_t _relative_save_offset;
11980                                 _relative_save_offset = ndr->offset;
11981                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
11982                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
11983                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
11984                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
11985                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
11986                                 ndr->offset = _relative_save_offset;
11987                         }
11988                         ndr->flags = _flags_save_string;
11989                 }
11990                 {
11991                         uint32_t _flags_save_string = ndr->flags;
11992                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
11993                         if (r->data_file) {
11994                                 uint32_t _relative_save_offset;
11995                                 _relative_save_offset = ndr->offset;
11996                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
11997                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
11998                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
11999                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12000                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12001                                 ndr->offset = _relative_save_offset;
12002                         }
12003                         ndr->flags = _flags_save_string;
12004                 }
12005                 {
12006                         uint32_t _flags_save_string = ndr->flags;
12007                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12008                         if (r->config_file) {
12009                                 uint32_t _relative_save_offset;
12010                                 _relative_save_offset = ndr->offset;
12011                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12012                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12013                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12014                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12015                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12016                                 ndr->offset = _relative_save_offset;
12017                         }
12018                         ndr->flags = _flags_save_string;
12019                 }
12020                 {
12021                         uint32_t _flags_save_string = ndr->flags;
12022                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12023                         if (r->help_file) {
12024                                 uint32_t _relative_save_offset;
12025                                 _relative_save_offset = ndr->offset;
12026                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12027                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12028                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12029                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12030                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12031                                 ndr->offset = _relative_save_offset;
12032                         }
12033                         ndr->flags = _flags_save_string;
12034                 }
12035                 {
12036                         uint32_t _flags_save_string_array = ndr->flags;
12037                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12038                         if (r->dependent_files) {
12039                                 uint32_t _relative_save_offset;
12040                                 _relative_save_offset = ndr->offset;
12041                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12042                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12043                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12044                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12045                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12046                                 ndr->offset = _relative_save_offset;
12047                         }
12048                         ndr->flags = _flags_save_string_array;
12049                 }
12050                 {
12051                         uint32_t _flags_save_string = ndr->flags;
12052                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12053                         if (r->monitor_name) {
12054                                 uint32_t _relative_save_offset;
12055                                 _relative_save_offset = ndr->offset;
12056                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12057                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12058                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12059                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12060                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12061                                 ndr->offset = _relative_save_offset;
12062                         }
12063                         ndr->flags = _flags_save_string;
12064                 }
12065                 {
12066                         uint32_t _flags_save_string = ndr->flags;
12067                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12068                         if (r->default_datatype) {
12069                                 uint32_t _relative_save_offset;
12070                                 _relative_save_offset = ndr->offset;
12071                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12072                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12073                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12074                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12075                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12076                                 ndr->offset = _relative_save_offset;
12077                         }
12078                         ndr->flags = _flags_save_string;
12079                 }
12080                 {
12081                         uint32_t _flags_save_string_array = ndr->flags;
12082                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12083                         if (r->previous_names) {
12084                                 uint32_t _relative_save_offset;
12085                                 _relative_save_offset = ndr->offset;
12086                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12087                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12088                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12089                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12090                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12091                                 ndr->offset = _relative_save_offset;
12092                         }
12093                         ndr->flags = _flags_save_string_array;
12094                 }
12095                 {
12096                         uint32_t _flags_save_string = ndr->flags;
12097                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12098                         if (r->manufacturer_name) {
12099                                 uint32_t _relative_save_offset;
12100                                 _relative_save_offset = ndr->offset;
12101                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12102                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12103                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12104                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12105                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12106                                 ndr->offset = _relative_save_offset;
12107                         }
12108                         ndr->flags = _flags_save_string;
12109                 }
12110                 {
12111                         uint32_t _flags_save_string = ndr->flags;
12112                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12113                         if (r->manufacturer_url) {
12114                                 uint32_t _relative_save_offset;
12115                                 _relative_save_offset = ndr->offset;
12116                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
12117                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
12118                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
12119                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
12120                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
12121                                 ndr->offset = _relative_save_offset;
12122                         }
12123                         ndr->flags = _flags_save_string;
12124                 }
12125                 {
12126                         uint32_t _flags_save_string = ndr->flags;
12127                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12128                         if (r->hardware_id) {
12129                                 uint32_t _relative_save_offset;
12130                                 _relative_save_offset = ndr->offset;
12131                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
12132                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
12133                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
12134                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
12135                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
12136                                 ndr->offset = _relative_save_offset;
12137                         }
12138                         ndr->flags = _flags_save_string;
12139                 }
12140                 {
12141                         uint32_t _flags_save_string = ndr->flags;
12142                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12143                         if (r->provider) {
12144                                 uint32_t _relative_save_offset;
12145                                 _relative_save_offset = ndr->offset;
12146                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
12147                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
12148                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
12149                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
12150                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
12151                                 ndr->offset = _relative_save_offset;
12152                         }
12153                         ndr->flags = _flags_save_string;
12154                 }
12155         }
12156         return NDR_ERR_SUCCESS;
12157 }
12158
12159 _PUBLIC_ void ndr_print_spoolss_DriverInfo6(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo6 *r)
12160 {
12161         ndr_print_struct(ndr, name, "spoolss_DriverInfo6");
12162         ndr->depth++;
12163         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
12164         ndr_print_ptr(ndr, "driver_name", r->driver_name);
12165         ndr->depth++;
12166         if (r->driver_name) {
12167                 ndr_print_string(ndr, "driver_name", r->driver_name);
12168         }
12169         ndr->depth--;
12170         ndr_print_ptr(ndr, "architecture", r->architecture);
12171         ndr->depth++;
12172         if (r->architecture) {
12173                 ndr_print_string(ndr, "architecture", r->architecture);
12174         }
12175         ndr->depth--;
12176         ndr_print_ptr(ndr, "driver_path", r->driver_path);
12177         ndr->depth++;
12178         if (r->driver_path) {
12179                 ndr_print_string(ndr, "driver_path", r->driver_path);
12180         }
12181         ndr->depth--;
12182         ndr_print_ptr(ndr, "data_file", r->data_file);
12183         ndr->depth++;
12184         if (r->data_file) {
12185                 ndr_print_string(ndr, "data_file", r->data_file);
12186         }
12187         ndr->depth--;
12188         ndr_print_ptr(ndr, "config_file", r->config_file);
12189         ndr->depth++;
12190         if (r->config_file) {
12191                 ndr_print_string(ndr, "config_file", r->config_file);
12192         }
12193         ndr->depth--;
12194         ndr_print_ptr(ndr, "help_file", r->help_file);
12195         ndr->depth++;
12196         if (r->help_file) {
12197                 ndr_print_string(ndr, "help_file", r->help_file);
12198         }
12199         ndr->depth--;
12200         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
12201         ndr->depth++;
12202         if (r->dependent_files) {
12203                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
12204         }
12205         ndr->depth--;
12206         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
12207         ndr->depth++;
12208         if (r->monitor_name) {
12209                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
12210         }
12211         ndr->depth--;
12212         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
12213         ndr->depth++;
12214         if (r->default_datatype) {
12215                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
12216         }
12217         ndr->depth--;
12218         ndr_print_ptr(ndr, "previous_names", r->previous_names);
12219         ndr->depth++;
12220         if (r->previous_names) {
12221                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
12222         }
12223         ndr->depth--;
12224         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
12225         ndr_print_hyper(ndr, "driver_version", r->driver_version);
12226         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
12227         ndr->depth++;
12228         if (r->manufacturer_name) {
12229                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
12230         }
12231         ndr->depth--;
12232         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
12233         ndr->depth++;
12234         if (r->manufacturer_url) {
12235                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
12236         }
12237         ndr->depth--;
12238         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
12239         ndr->depth++;
12240         if (r->hardware_id) {
12241                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
12242         }
12243         ndr->depth--;
12244         ndr_print_ptr(ndr, "provider", r->provider);
12245         ndr->depth++;
12246         if (r->provider) {
12247                 ndr_print_string(ndr, "provider", r->provider);
12248         }
12249         ndr->depth--;
12250         ndr->depth--;
12251 }
12252
12253 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo6(const struct spoolss_DriverInfo6 *r, struct smb_iconv_convenience *ic, int flags)
12254 {
12255         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo6, ic);
12256 }
12257
12258 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo8(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverInfo8 *r)
12259 {
12260         if (ndr_flags & NDR_SCALARS) {
12261                 NDR_CHECK(ndr_push_align(ndr, 8));
12262                 NDR_CHECK(ndr_push_spoolss_DriverOSVersion(ndr, NDR_SCALARS, r->version));
12263                 {
12264                         uint32_t _flags_save_string = ndr->flags;
12265                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12266                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_name));
12267                         ndr->flags = _flags_save_string;
12268                 }
12269                 {
12270                         uint32_t _flags_save_string = ndr->flags;
12271                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12272                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->architecture));
12273                         ndr->flags = _flags_save_string;
12274                 }
12275                 {
12276                         uint32_t _flags_save_string = ndr->flags;
12277                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12278                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->driver_path));
12279                         ndr->flags = _flags_save_string;
12280                 }
12281                 {
12282                         uint32_t _flags_save_string = ndr->flags;
12283                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12284                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data_file));
12285                         ndr->flags = _flags_save_string;
12286                 }
12287                 {
12288                         uint32_t _flags_save_string = ndr->flags;
12289                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12290                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->config_file));
12291                         ndr->flags = _flags_save_string;
12292                 }
12293                 {
12294                         uint32_t _flags_save_string = ndr->flags;
12295                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12296                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->help_file));
12297                         ndr->flags = _flags_save_string;
12298                 }
12299                 {
12300                         uint32_t _flags_save_string = ndr->flags;
12301                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12302                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
12303                         ndr->flags = _flags_save_string;
12304                 }
12305                 {
12306                         uint32_t _flags_save_string = ndr->flags;
12307                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12308                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->default_datatype));
12309                         ndr->flags = _flags_save_string;
12310                 }
12311                 {
12312                         uint32_t _flags_save_string_array = ndr->flags;
12313                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12314                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dependent_files));
12315                         ndr->flags = _flags_save_string_array;
12316                 }
12317                 {
12318                         uint32_t _flags_save_string_array = ndr->flags;
12319                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12320                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->previous_names));
12321                         ndr->flags = _flags_save_string_array;
12322                 }
12323                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->driver_date));
12324                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->driver_version));
12325                 {
12326                         uint32_t _flags_save_string = ndr->flags;
12327                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12328                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_name));
12329                         ndr->flags = _flags_save_string;
12330                 }
12331                 {
12332                         uint32_t _flags_save_string = ndr->flags;
12333                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12334                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->manufacturer_url));
12335                         ndr->flags = _flags_save_string;
12336                 }
12337                 {
12338                         uint32_t _flags_save_string = ndr->flags;
12339                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12340                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->hardware_id));
12341                         ndr->flags = _flags_save_string;
12342                 }
12343                 {
12344                         uint32_t _flags_save_string = ndr->flags;
12345                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12346                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->provider));
12347                         ndr->flags = _flags_save_string;
12348                 }
12349                 {
12350                         uint32_t _flags_save_string = ndr->flags;
12351                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12352                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor));
12353                         ndr->flags = _flags_save_string;
12354                 }
12355                 {
12356                         uint32_t _flags_save_string = ndr->flags;
12357                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12358                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->vendor_setup));
12359                         ndr->flags = _flags_save_string;
12360                 }
12361                 {
12362                         uint32_t _flags_save_string_array = ndr->flags;
12363                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12364                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->color_profiles));
12365                         ndr->flags = _flags_save_string_array;
12366                 }
12367                 {
12368                         uint32_t _flags_save_string = ndr->flags;
12369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12370                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->inf_path));
12371                         ndr->flags = _flags_save_string;
12372                 }
12373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->printer_driver_attributes));
12374                 {
12375                         uint32_t _flags_save_string_array = ndr->flags;
12376                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12377                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->core_driver_dependencies));
12378                         ndr->flags = _flags_save_string_array;
12379                 }
12380                 NDR_CHECK(ndr_push_NTTIME(ndr, NDR_SCALARS, r->min_inbox_driver_ver_date));
12381                 NDR_CHECK(ndr_push_hyper(ndr, NDR_SCALARS, r->min_inbox_driver_ver_version));
12382         }
12383         if (ndr_flags & NDR_BUFFERS) {
12384                 {
12385                         uint32_t _flags_save_string = ndr->flags;
12386                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12387                         if (r->driver_name) {
12388                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_name));
12389                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_name));
12390                         }
12391                         ndr->flags = _flags_save_string;
12392                 }
12393                 {
12394                         uint32_t _flags_save_string = ndr->flags;
12395                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12396                         if (r->architecture) {
12397                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->architecture));
12398                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->architecture));
12399                         }
12400                         ndr->flags = _flags_save_string;
12401                 }
12402                 {
12403                         uint32_t _flags_save_string = ndr->flags;
12404                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12405                         if (r->driver_path) {
12406                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->driver_path));
12407                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->driver_path));
12408                         }
12409                         ndr->flags = _flags_save_string;
12410                 }
12411                 {
12412                         uint32_t _flags_save_string = ndr->flags;
12413                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12414                         if (r->data_file) {
12415                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data_file));
12416                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->data_file));
12417                         }
12418                         ndr->flags = _flags_save_string;
12419                 }
12420                 {
12421                         uint32_t _flags_save_string = ndr->flags;
12422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12423                         if (r->config_file) {
12424                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->config_file));
12425                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->config_file));
12426                         }
12427                         ndr->flags = _flags_save_string;
12428                 }
12429                 {
12430                         uint32_t _flags_save_string = ndr->flags;
12431                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12432                         if (r->help_file) {
12433                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->help_file));
12434                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->help_file));
12435                         }
12436                         ndr->flags = _flags_save_string;
12437                 }
12438                 {
12439                         uint32_t _flags_save_string = ndr->flags;
12440                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12441                         if (r->monitor_name) {
12442                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
12443                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
12444                         }
12445                         ndr->flags = _flags_save_string;
12446                 }
12447                 {
12448                         uint32_t _flags_save_string = ndr->flags;
12449                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12450                         if (r->default_datatype) {
12451                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->default_datatype));
12452                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->default_datatype));
12453                         }
12454                         ndr->flags = _flags_save_string;
12455                 }
12456                 {
12457                         uint32_t _flags_save_string_array = ndr->flags;
12458                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12459                         if (r->dependent_files) {
12460                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dependent_files));
12461                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->dependent_files));
12462                         }
12463                         ndr->flags = _flags_save_string_array;
12464                 }
12465                 {
12466                         uint32_t _flags_save_string_array = ndr->flags;
12467                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12468                         if (r->previous_names) {
12469                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->previous_names));
12470                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->previous_names));
12471                         }
12472                         ndr->flags = _flags_save_string_array;
12473                 }
12474                 {
12475                         uint32_t _flags_save_string = ndr->flags;
12476                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12477                         if (r->manufacturer_name) {
12478                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_name));
12479                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_name));
12480                         }
12481                         ndr->flags = _flags_save_string;
12482                 }
12483                 {
12484                         uint32_t _flags_save_string = ndr->flags;
12485                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12486                         if (r->manufacturer_url) {
12487                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->manufacturer_url));
12488                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->manufacturer_url));
12489                         }
12490                         ndr->flags = _flags_save_string;
12491                 }
12492                 {
12493                         uint32_t _flags_save_string = ndr->flags;
12494                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12495                         if (r->hardware_id) {
12496                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->hardware_id));
12497                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->hardware_id));
12498                         }
12499                         ndr->flags = _flags_save_string;
12500                 }
12501                 {
12502                         uint32_t _flags_save_string = ndr->flags;
12503                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12504                         if (r->provider) {
12505                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->provider));
12506                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->provider));
12507                         }
12508                         ndr->flags = _flags_save_string;
12509                 }
12510                 {
12511                         uint32_t _flags_save_string = ndr->flags;
12512                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12513                         if (r->print_processor) {
12514                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor));
12515                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor));
12516                         }
12517                         ndr->flags = _flags_save_string;
12518                 }
12519                 {
12520                         uint32_t _flags_save_string = ndr->flags;
12521                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12522                         if (r->vendor_setup) {
12523                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->vendor_setup));
12524                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->vendor_setup));
12525                         }
12526                         ndr->flags = _flags_save_string;
12527                 }
12528                 {
12529                         uint32_t _flags_save_string_array = ndr->flags;
12530                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12531                         if (r->color_profiles) {
12532                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->color_profiles));
12533                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->color_profiles));
12534                         }
12535                         ndr->flags = _flags_save_string_array;
12536                 }
12537                 {
12538                         uint32_t _flags_save_string = ndr->flags;
12539                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12540                         if (r->inf_path) {
12541                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->inf_path));
12542                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->inf_path));
12543                         }
12544                         ndr->flags = _flags_save_string;
12545                 }
12546                 {
12547                         uint32_t _flags_save_string_array = ndr->flags;
12548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12549                         if (r->core_driver_dependencies) {
12550                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->core_driver_dependencies));
12551                                 NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->core_driver_dependencies));
12552                         }
12553                         ndr->flags = _flags_save_string_array;
12554                 }
12555         }
12556         return NDR_ERR_SUCCESS;
12557 }
12558
12559 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo8(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverInfo8 *r)
12560 {
12561         uint32_t _ptr_driver_name;
12562         TALLOC_CTX *_mem_save_driver_name_0;
12563         uint32_t _ptr_architecture;
12564         TALLOC_CTX *_mem_save_architecture_0;
12565         uint32_t _ptr_driver_path;
12566         TALLOC_CTX *_mem_save_driver_path_0;
12567         uint32_t _ptr_data_file;
12568         TALLOC_CTX *_mem_save_data_file_0;
12569         uint32_t _ptr_config_file;
12570         TALLOC_CTX *_mem_save_config_file_0;
12571         uint32_t _ptr_help_file;
12572         TALLOC_CTX *_mem_save_help_file_0;
12573         uint32_t _ptr_monitor_name;
12574         TALLOC_CTX *_mem_save_monitor_name_0;
12575         uint32_t _ptr_default_datatype;
12576         TALLOC_CTX *_mem_save_default_datatype_0;
12577         uint32_t _ptr_dependent_files;
12578         TALLOC_CTX *_mem_save_dependent_files_0;
12579         uint32_t _ptr_previous_names;
12580         TALLOC_CTX *_mem_save_previous_names_0;
12581         uint32_t _ptr_manufacturer_name;
12582         TALLOC_CTX *_mem_save_manufacturer_name_0;
12583         uint32_t _ptr_manufacturer_url;
12584         TALLOC_CTX *_mem_save_manufacturer_url_0;
12585         uint32_t _ptr_hardware_id;
12586         TALLOC_CTX *_mem_save_hardware_id_0;
12587         uint32_t _ptr_provider;
12588         TALLOC_CTX *_mem_save_provider_0;
12589         uint32_t _ptr_print_processor;
12590         TALLOC_CTX *_mem_save_print_processor_0;
12591         uint32_t _ptr_vendor_setup;
12592         TALLOC_CTX *_mem_save_vendor_setup_0;
12593         uint32_t _ptr_color_profiles;
12594         TALLOC_CTX *_mem_save_color_profiles_0;
12595         uint32_t _ptr_inf_path;
12596         TALLOC_CTX *_mem_save_inf_path_0;
12597         uint32_t _ptr_core_driver_dependencies;
12598         TALLOC_CTX *_mem_save_core_driver_dependencies_0;
12599         if (ndr_flags & NDR_SCALARS) {
12600                 NDR_CHECK(ndr_pull_align(ndr, 8));
12601                 NDR_CHECK(ndr_pull_spoolss_DriverOSVersion(ndr, NDR_SCALARS, &r->version));
12602                 {
12603                         uint32_t _flags_save_string = ndr->flags;
12604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12605                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_name));
12606                         if (_ptr_driver_name) {
12607                                 NDR_PULL_ALLOC(ndr, r->driver_name);
12608                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_name, _ptr_driver_name));
12609                         } else {
12610                                 r->driver_name = NULL;
12611                         }
12612                         ndr->flags = _flags_save_string;
12613                 }
12614                 {
12615                         uint32_t _flags_save_string = ndr->flags;
12616                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12617                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
12618                         if (_ptr_architecture) {
12619                                 NDR_PULL_ALLOC(ndr, r->architecture);
12620                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->architecture, _ptr_architecture));
12621                         } else {
12622                                 r->architecture = NULL;
12623                         }
12624                         ndr->flags = _flags_save_string;
12625                 }
12626                 {
12627                         uint32_t _flags_save_string = ndr->flags;
12628                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12629                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_driver_path));
12630                         if (_ptr_driver_path) {
12631                                 NDR_PULL_ALLOC(ndr, r->driver_path);
12632                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->driver_path, _ptr_driver_path));
12633                         } else {
12634                                 r->driver_path = NULL;
12635                         }
12636                         ndr->flags = _flags_save_string;
12637                 }
12638                 {
12639                         uint32_t _flags_save_string = ndr->flags;
12640                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12641                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_file));
12642                         if (_ptr_data_file) {
12643                                 NDR_PULL_ALLOC(ndr, r->data_file);
12644                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data_file, _ptr_data_file));
12645                         } else {
12646                                 r->data_file = NULL;
12647                         }
12648                         ndr->flags = _flags_save_string;
12649                 }
12650                 {
12651                         uint32_t _flags_save_string = ndr->flags;
12652                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12653                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_config_file));
12654                         if (_ptr_config_file) {
12655                                 NDR_PULL_ALLOC(ndr, r->config_file);
12656                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->config_file, _ptr_config_file));
12657                         } else {
12658                                 r->config_file = NULL;
12659                         }
12660                         ndr->flags = _flags_save_string;
12661                 }
12662                 {
12663                         uint32_t _flags_save_string = ndr->flags;
12664                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12665                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_help_file));
12666                         if (_ptr_help_file) {
12667                                 NDR_PULL_ALLOC(ndr, r->help_file);
12668                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->help_file, _ptr_help_file));
12669                         } else {
12670                                 r->help_file = NULL;
12671                         }
12672                         ndr->flags = _flags_save_string;
12673                 }
12674                 {
12675                         uint32_t _flags_save_string = ndr->flags;
12676                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12677                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
12678                         if (_ptr_monitor_name) {
12679                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
12680                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
12681                         } else {
12682                                 r->monitor_name = NULL;
12683                         }
12684                         ndr->flags = _flags_save_string;
12685                 }
12686                 {
12687                         uint32_t _flags_save_string = ndr->flags;
12688                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12689                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_default_datatype));
12690                         if (_ptr_default_datatype) {
12691                                 NDR_PULL_ALLOC(ndr, r->default_datatype);
12692                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->default_datatype, _ptr_default_datatype));
12693                         } else {
12694                                 r->default_datatype = NULL;
12695                         }
12696                         ndr->flags = _flags_save_string;
12697                 }
12698                 {
12699                         uint32_t _flags_save_string_array = ndr->flags;
12700                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12701                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dependent_files));
12702                         if (_ptr_dependent_files) {
12703                                 NDR_PULL_ALLOC(ndr, r->dependent_files);
12704                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dependent_files, _ptr_dependent_files));
12705                         } else {
12706                                 r->dependent_files = NULL;
12707                         }
12708                         ndr->flags = _flags_save_string_array;
12709                 }
12710                 {
12711                         uint32_t _flags_save_string_array = ndr->flags;
12712                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12713                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_previous_names));
12714                         if (_ptr_previous_names) {
12715                                 NDR_PULL_ALLOC(ndr, r->previous_names);
12716                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->previous_names, _ptr_previous_names));
12717                         } else {
12718                                 r->previous_names = NULL;
12719                         }
12720                         ndr->flags = _flags_save_string_array;
12721                 }
12722                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->driver_date));
12723                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->driver_version));
12724                 {
12725                         uint32_t _flags_save_string = ndr->flags;
12726                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12727                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_name));
12728                         if (_ptr_manufacturer_name) {
12729                                 NDR_PULL_ALLOC(ndr, r->manufacturer_name);
12730                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_name, _ptr_manufacturer_name));
12731                         } else {
12732                                 r->manufacturer_name = NULL;
12733                         }
12734                         ndr->flags = _flags_save_string;
12735                 }
12736                 {
12737                         uint32_t _flags_save_string = ndr->flags;
12738                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12739                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_manufacturer_url));
12740                         if (_ptr_manufacturer_url) {
12741                                 NDR_PULL_ALLOC(ndr, r->manufacturer_url);
12742                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->manufacturer_url, _ptr_manufacturer_url));
12743                         } else {
12744                                 r->manufacturer_url = NULL;
12745                         }
12746                         ndr->flags = _flags_save_string;
12747                 }
12748                 {
12749                         uint32_t _flags_save_string = ndr->flags;
12750                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12751                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_hardware_id));
12752                         if (_ptr_hardware_id) {
12753                                 NDR_PULL_ALLOC(ndr, r->hardware_id);
12754                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->hardware_id, _ptr_hardware_id));
12755                         } else {
12756                                 r->hardware_id = NULL;
12757                         }
12758                         ndr->flags = _flags_save_string;
12759                 }
12760                 {
12761                         uint32_t _flags_save_string = ndr->flags;
12762                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12763                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_provider));
12764                         if (_ptr_provider) {
12765                                 NDR_PULL_ALLOC(ndr, r->provider);
12766                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->provider, _ptr_provider));
12767                         } else {
12768                                 r->provider = NULL;
12769                         }
12770                         ndr->flags = _flags_save_string;
12771                 }
12772                 {
12773                         uint32_t _flags_save_string = ndr->flags;
12774                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12775                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor));
12776                         if (_ptr_print_processor) {
12777                                 NDR_PULL_ALLOC(ndr, r->print_processor);
12778                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor, _ptr_print_processor));
12779                         } else {
12780                                 r->print_processor = NULL;
12781                         }
12782                         ndr->flags = _flags_save_string;
12783                 }
12784                 {
12785                         uint32_t _flags_save_string = ndr->flags;
12786                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12787                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_vendor_setup));
12788                         if (_ptr_vendor_setup) {
12789                                 NDR_PULL_ALLOC(ndr, r->vendor_setup);
12790                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->vendor_setup, _ptr_vendor_setup));
12791                         } else {
12792                                 r->vendor_setup = NULL;
12793                         }
12794                         ndr->flags = _flags_save_string;
12795                 }
12796                 {
12797                         uint32_t _flags_save_string_array = ndr->flags;
12798                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12799                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_color_profiles));
12800                         if (_ptr_color_profiles) {
12801                                 NDR_PULL_ALLOC(ndr, r->color_profiles);
12802                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->color_profiles, _ptr_color_profiles));
12803                         } else {
12804                                 r->color_profiles = NULL;
12805                         }
12806                         ndr->flags = _flags_save_string_array;
12807                 }
12808                 {
12809                         uint32_t _flags_save_string = ndr->flags;
12810                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12811                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_inf_path));
12812                         if (_ptr_inf_path) {
12813                                 NDR_PULL_ALLOC(ndr, r->inf_path);
12814                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->inf_path, _ptr_inf_path));
12815                         } else {
12816                                 r->inf_path = NULL;
12817                         }
12818                         ndr->flags = _flags_save_string;
12819                 }
12820                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->printer_driver_attributes));
12821                 {
12822                         uint32_t _flags_save_string_array = ndr->flags;
12823                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12824                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_core_driver_dependencies));
12825                         if (_ptr_core_driver_dependencies) {
12826                                 NDR_PULL_ALLOC(ndr, r->core_driver_dependencies);
12827                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->core_driver_dependencies, _ptr_core_driver_dependencies));
12828                         } else {
12829                                 r->core_driver_dependencies = NULL;
12830                         }
12831                         ndr->flags = _flags_save_string_array;
12832                 }
12833                 NDR_CHECK(ndr_pull_NTTIME(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_date));
12834                 NDR_CHECK(ndr_pull_hyper(ndr, NDR_SCALARS, &r->min_inbox_driver_ver_version));
12835         }
12836         if (ndr_flags & NDR_BUFFERS) {
12837                 {
12838                         uint32_t _flags_save_string = ndr->flags;
12839                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12840                         if (r->driver_name) {
12841                                 uint32_t _relative_save_offset;
12842                                 _relative_save_offset = ndr->offset;
12843                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_name));
12844                                 _mem_save_driver_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12845                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_name, 0);
12846                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_name));
12847                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_name_0, 0);
12848                                 ndr->offset = _relative_save_offset;
12849                         }
12850                         ndr->flags = _flags_save_string;
12851                 }
12852                 {
12853                         uint32_t _flags_save_string = ndr->flags;
12854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12855                         if (r->architecture) {
12856                                 uint32_t _relative_save_offset;
12857                                 _relative_save_offset = ndr->offset;
12858                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->architecture));
12859                                 _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
12860                                 NDR_PULL_SET_MEM_CTX(ndr, r->architecture, 0);
12861                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->architecture));
12862                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
12863                                 ndr->offset = _relative_save_offset;
12864                         }
12865                         ndr->flags = _flags_save_string;
12866                 }
12867                 {
12868                         uint32_t _flags_save_string = ndr->flags;
12869                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12870                         if (r->driver_path) {
12871                                 uint32_t _relative_save_offset;
12872                                 _relative_save_offset = ndr->offset;
12873                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->driver_path));
12874                                 _mem_save_driver_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
12875                                 NDR_PULL_SET_MEM_CTX(ndr, r->driver_path, 0);
12876                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->driver_path));
12877                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_driver_path_0, 0);
12878                                 ndr->offset = _relative_save_offset;
12879                         }
12880                         ndr->flags = _flags_save_string;
12881                 }
12882                 {
12883                         uint32_t _flags_save_string = ndr->flags;
12884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12885                         if (r->data_file) {
12886                                 uint32_t _relative_save_offset;
12887                                 _relative_save_offset = ndr->offset;
12888                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data_file));
12889                                 _mem_save_data_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12890                                 NDR_PULL_SET_MEM_CTX(ndr, r->data_file, 0);
12891                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->data_file));
12892                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_file_0, 0);
12893                                 ndr->offset = _relative_save_offset;
12894                         }
12895                         ndr->flags = _flags_save_string;
12896                 }
12897                 {
12898                         uint32_t _flags_save_string = ndr->flags;
12899                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12900                         if (r->config_file) {
12901                                 uint32_t _relative_save_offset;
12902                                 _relative_save_offset = ndr->offset;
12903                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->config_file));
12904                                 _mem_save_config_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12905                                 NDR_PULL_SET_MEM_CTX(ndr, r->config_file, 0);
12906                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->config_file));
12907                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_config_file_0, 0);
12908                                 ndr->offset = _relative_save_offset;
12909                         }
12910                         ndr->flags = _flags_save_string;
12911                 }
12912                 {
12913                         uint32_t _flags_save_string = ndr->flags;
12914                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12915                         if (r->help_file) {
12916                                 uint32_t _relative_save_offset;
12917                                 _relative_save_offset = ndr->offset;
12918                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->help_file));
12919                                 _mem_save_help_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
12920                                 NDR_PULL_SET_MEM_CTX(ndr, r->help_file, 0);
12921                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->help_file));
12922                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_help_file_0, 0);
12923                                 ndr->offset = _relative_save_offset;
12924                         }
12925                         ndr->flags = _flags_save_string;
12926                 }
12927                 {
12928                         uint32_t _flags_save_string = ndr->flags;
12929                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12930                         if (r->monitor_name) {
12931                                 uint32_t _relative_save_offset;
12932                                 _relative_save_offset = ndr->offset;
12933                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
12934                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12935                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
12936                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
12937                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
12938                                 ndr->offset = _relative_save_offset;
12939                         }
12940                         ndr->flags = _flags_save_string;
12941                 }
12942                 {
12943                         uint32_t _flags_save_string = ndr->flags;
12944                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12945                         if (r->default_datatype) {
12946                                 uint32_t _relative_save_offset;
12947                                 _relative_save_offset = ndr->offset;
12948                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->default_datatype));
12949                                 _mem_save_default_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
12950                                 NDR_PULL_SET_MEM_CTX(ndr, r->default_datatype, 0);
12951                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->default_datatype));
12952                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_default_datatype_0, 0);
12953                                 ndr->offset = _relative_save_offset;
12954                         }
12955                         ndr->flags = _flags_save_string;
12956                 }
12957                 {
12958                         uint32_t _flags_save_string_array = ndr->flags;
12959                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12960                         if (r->dependent_files) {
12961                                 uint32_t _relative_save_offset;
12962                                 _relative_save_offset = ndr->offset;
12963                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dependent_files));
12964                                 _mem_save_dependent_files_0 = NDR_PULL_GET_MEM_CTX(ndr);
12965                                 NDR_PULL_SET_MEM_CTX(ndr, r->dependent_files, 0);
12966                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->dependent_files));
12967                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dependent_files_0, 0);
12968                                 ndr->offset = _relative_save_offset;
12969                         }
12970                         ndr->flags = _flags_save_string_array;
12971                 }
12972                 {
12973                         uint32_t _flags_save_string_array = ndr->flags;
12974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12975                         if (r->previous_names) {
12976                                 uint32_t _relative_save_offset;
12977                                 _relative_save_offset = ndr->offset;
12978                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->previous_names));
12979                                 _mem_save_previous_names_0 = NDR_PULL_GET_MEM_CTX(ndr);
12980                                 NDR_PULL_SET_MEM_CTX(ndr, r->previous_names, 0);
12981                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->previous_names));
12982                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_previous_names_0, 0);
12983                                 ndr->offset = _relative_save_offset;
12984                         }
12985                         ndr->flags = _flags_save_string_array;
12986                 }
12987                 {
12988                         uint32_t _flags_save_string = ndr->flags;
12989                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
12990                         if (r->manufacturer_name) {
12991                                 uint32_t _relative_save_offset;
12992                                 _relative_save_offset = ndr->offset;
12993                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_name));
12994                                 _mem_save_manufacturer_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
12995                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_name, 0);
12996                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_name));
12997                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_name_0, 0);
12998                                 ndr->offset = _relative_save_offset;
12999                         }
13000                         ndr->flags = _flags_save_string;
13001                 }
13002                 {
13003                         uint32_t _flags_save_string = ndr->flags;
13004                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13005                         if (r->manufacturer_url) {
13006                                 uint32_t _relative_save_offset;
13007                                 _relative_save_offset = ndr->offset;
13008                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->manufacturer_url));
13009                                 _mem_save_manufacturer_url_0 = NDR_PULL_GET_MEM_CTX(ndr);
13010                                 NDR_PULL_SET_MEM_CTX(ndr, r->manufacturer_url, 0);
13011                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->manufacturer_url));
13012                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_manufacturer_url_0, 0);
13013                                 ndr->offset = _relative_save_offset;
13014                         }
13015                         ndr->flags = _flags_save_string;
13016                 }
13017                 {
13018                         uint32_t _flags_save_string = ndr->flags;
13019                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13020                         if (r->hardware_id) {
13021                                 uint32_t _relative_save_offset;
13022                                 _relative_save_offset = ndr->offset;
13023                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->hardware_id));
13024                                 _mem_save_hardware_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
13025                                 NDR_PULL_SET_MEM_CTX(ndr, r->hardware_id, 0);
13026                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->hardware_id));
13027                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_hardware_id_0, 0);
13028                                 ndr->offset = _relative_save_offset;
13029                         }
13030                         ndr->flags = _flags_save_string;
13031                 }
13032                 {
13033                         uint32_t _flags_save_string = ndr->flags;
13034                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13035                         if (r->provider) {
13036                                 uint32_t _relative_save_offset;
13037                                 _relative_save_offset = ndr->offset;
13038                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->provider));
13039                                 _mem_save_provider_0 = NDR_PULL_GET_MEM_CTX(ndr);
13040                                 NDR_PULL_SET_MEM_CTX(ndr, r->provider, 0);
13041                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->provider));
13042                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_provider_0, 0);
13043                                 ndr->offset = _relative_save_offset;
13044                         }
13045                         ndr->flags = _flags_save_string;
13046                 }
13047                 {
13048                         uint32_t _flags_save_string = ndr->flags;
13049                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13050                         if (r->print_processor) {
13051                                 uint32_t _relative_save_offset;
13052                                 _relative_save_offset = ndr->offset;
13053                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor));
13054                                 _mem_save_print_processor_0 = NDR_PULL_GET_MEM_CTX(ndr);
13055                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor, 0);
13056                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor));
13057                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_0, 0);
13058                                 ndr->offset = _relative_save_offset;
13059                         }
13060                         ndr->flags = _flags_save_string;
13061                 }
13062                 {
13063                         uint32_t _flags_save_string = ndr->flags;
13064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13065                         if (r->vendor_setup) {
13066                                 uint32_t _relative_save_offset;
13067                                 _relative_save_offset = ndr->offset;
13068                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->vendor_setup));
13069                                 _mem_save_vendor_setup_0 = NDR_PULL_GET_MEM_CTX(ndr);
13070                                 NDR_PULL_SET_MEM_CTX(ndr, r->vendor_setup, 0);
13071                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->vendor_setup));
13072                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_vendor_setup_0, 0);
13073                                 ndr->offset = _relative_save_offset;
13074                         }
13075                         ndr->flags = _flags_save_string;
13076                 }
13077                 {
13078                         uint32_t _flags_save_string_array = ndr->flags;
13079                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13080                         if (r->color_profiles) {
13081                                 uint32_t _relative_save_offset;
13082                                 _relative_save_offset = ndr->offset;
13083                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->color_profiles));
13084                                 _mem_save_color_profiles_0 = NDR_PULL_GET_MEM_CTX(ndr);
13085                                 NDR_PULL_SET_MEM_CTX(ndr, r->color_profiles, 0);
13086                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->color_profiles));
13087                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_color_profiles_0, 0);
13088                                 ndr->offset = _relative_save_offset;
13089                         }
13090                         ndr->flags = _flags_save_string_array;
13091                 }
13092                 {
13093                         uint32_t _flags_save_string = ndr->flags;
13094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13095                         if (r->inf_path) {
13096                                 uint32_t _relative_save_offset;
13097                                 _relative_save_offset = ndr->offset;
13098                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->inf_path));
13099                                 _mem_save_inf_path_0 = NDR_PULL_GET_MEM_CTX(ndr);
13100                                 NDR_PULL_SET_MEM_CTX(ndr, r->inf_path, 0);
13101                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->inf_path));
13102                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_inf_path_0, 0);
13103                                 ndr->offset = _relative_save_offset;
13104                         }
13105                         ndr->flags = _flags_save_string;
13106                 }
13107                 {
13108                         uint32_t _flags_save_string_array = ndr->flags;
13109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13110                         if (r->core_driver_dependencies) {
13111                                 uint32_t _relative_save_offset;
13112                                 _relative_save_offset = ndr->offset;
13113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->core_driver_dependencies));
13114                                 _mem_save_core_driver_dependencies_0 = NDR_PULL_GET_MEM_CTX(ndr);
13115                                 NDR_PULL_SET_MEM_CTX(ndr, r->core_driver_dependencies, 0);
13116                                 NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->core_driver_dependencies));
13117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_core_driver_dependencies_0, 0);
13118                                 ndr->offset = _relative_save_offset;
13119                         }
13120                         ndr->flags = _flags_save_string_array;
13121                 }
13122         }
13123         return NDR_ERR_SUCCESS;
13124 }
13125
13126 _PUBLIC_ void ndr_print_spoolss_DriverInfo8(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo8 *r)
13127 {
13128         ndr_print_struct(ndr, name, "spoolss_DriverInfo8");
13129         ndr->depth++;
13130         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13131         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13132         ndr->depth++;
13133         if (r->driver_name) {
13134                 ndr_print_string(ndr, "driver_name", r->driver_name);
13135         }
13136         ndr->depth--;
13137         ndr_print_ptr(ndr, "architecture", r->architecture);
13138         ndr->depth++;
13139         if (r->architecture) {
13140                 ndr_print_string(ndr, "architecture", r->architecture);
13141         }
13142         ndr->depth--;
13143         ndr_print_ptr(ndr, "driver_path", r->driver_path);
13144         ndr->depth++;
13145         if (r->driver_path) {
13146                 ndr_print_string(ndr, "driver_path", r->driver_path);
13147         }
13148         ndr->depth--;
13149         ndr_print_ptr(ndr, "data_file", r->data_file);
13150         ndr->depth++;
13151         if (r->data_file) {
13152                 ndr_print_string(ndr, "data_file", r->data_file);
13153         }
13154         ndr->depth--;
13155         ndr_print_ptr(ndr, "config_file", r->config_file);
13156         ndr->depth++;
13157         if (r->config_file) {
13158                 ndr_print_string(ndr, "config_file", r->config_file);
13159         }
13160         ndr->depth--;
13161         ndr_print_ptr(ndr, "help_file", r->help_file);
13162         ndr->depth++;
13163         if (r->help_file) {
13164                 ndr_print_string(ndr, "help_file", r->help_file);
13165         }
13166         ndr->depth--;
13167         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13168         ndr->depth++;
13169         if (r->monitor_name) {
13170                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13171         }
13172         ndr->depth--;
13173         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13174         ndr->depth++;
13175         if (r->default_datatype) {
13176                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13177         }
13178         ndr->depth--;
13179         ndr_print_ptr(ndr, "dependent_files", r->dependent_files);
13180         ndr->depth++;
13181         if (r->dependent_files) {
13182                 ndr_print_string_array(ndr, "dependent_files", r->dependent_files);
13183         }
13184         ndr->depth--;
13185         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13186         ndr->depth++;
13187         if (r->previous_names) {
13188                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13189         }
13190         ndr->depth--;
13191         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13192         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13193         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13194         ndr->depth++;
13195         if (r->manufacturer_name) {
13196                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13197         }
13198         ndr->depth--;
13199         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13200         ndr->depth++;
13201         if (r->manufacturer_url) {
13202                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13203         }
13204         ndr->depth--;
13205         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13206         ndr->depth++;
13207         if (r->hardware_id) {
13208                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13209         }
13210         ndr->depth--;
13211         ndr_print_ptr(ndr, "provider", r->provider);
13212         ndr->depth++;
13213         if (r->provider) {
13214                 ndr_print_string(ndr, "provider", r->provider);
13215         }
13216         ndr->depth--;
13217         ndr_print_ptr(ndr, "print_processor", r->print_processor);
13218         ndr->depth++;
13219         if (r->print_processor) {
13220                 ndr_print_string(ndr, "print_processor", r->print_processor);
13221         }
13222         ndr->depth--;
13223         ndr_print_ptr(ndr, "vendor_setup", r->vendor_setup);
13224         ndr->depth++;
13225         if (r->vendor_setup) {
13226                 ndr_print_string(ndr, "vendor_setup", r->vendor_setup);
13227         }
13228         ndr->depth--;
13229         ndr_print_ptr(ndr, "color_profiles", r->color_profiles);
13230         ndr->depth++;
13231         if (r->color_profiles) {
13232                 ndr_print_string_array(ndr, "color_profiles", r->color_profiles);
13233         }
13234         ndr->depth--;
13235         ndr_print_ptr(ndr, "inf_path", r->inf_path);
13236         ndr->depth++;
13237         if (r->inf_path) {
13238                 ndr_print_string(ndr, "inf_path", r->inf_path);
13239         }
13240         ndr->depth--;
13241         ndr_print_uint32(ndr, "printer_driver_attributes", r->printer_driver_attributes);
13242         ndr_print_ptr(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13243         ndr->depth++;
13244         if (r->core_driver_dependencies) {
13245                 ndr_print_string_array(ndr, "core_driver_dependencies", r->core_driver_dependencies);
13246         }
13247         ndr->depth--;
13248         ndr_print_NTTIME(ndr, "min_inbox_driver_ver_date", r->min_inbox_driver_ver_date);
13249         ndr_print_hyper(ndr, "min_inbox_driver_ver_version", r->min_inbox_driver_ver_version);
13250         ndr->depth--;
13251 }
13252
13253 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo8(const struct spoolss_DriverInfo8 *r, struct smb_iconv_convenience *ic, int flags)
13254 {
13255         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo8, ic);
13256 }
13257
13258 static enum ndr_err_code ndr_push_spoolss_DriverFileType(struct ndr_push *ndr, int ndr_flags, enum spoolss_DriverFileType r)
13259 {
13260         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
13261         return NDR_ERR_SUCCESS;
13262 }
13263
13264 static enum ndr_err_code ndr_pull_spoolss_DriverFileType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_DriverFileType *r)
13265 {
13266         uint32_t v;
13267         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
13268         *r = v;
13269         return NDR_ERR_SUCCESS;
13270 }
13271
13272 _PUBLIC_ void ndr_print_spoolss_DriverFileType(struct ndr_print *ndr, const char *name, enum spoolss_DriverFileType r)
13273 {
13274         const char *val = NULL;
13275
13276         switch (r) {
13277                 case SPOOLSS_DRIVER_FILE_TYPE_RENDERING: val = "SPOOLSS_DRIVER_FILE_TYPE_RENDERING"; break;
13278                 case SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION: val = "SPOOLSS_DRIVER_FILE_TYPE_CONFIGURATION"; break;
13279                 case SPOOLSS_DRIVER_FILE_TYPE_DATA: val = "SPOOLSS_DRIVER_FILE_TYPE_DATA"; break;
13280                 case SPOOLSS_DRIVER_FILE_TYPE_HELP: val = "SPOOLSS_DRIVER_FILE_TYPE_HELP"; break;
13281                 case SPOOLSS_DRIVER_FILE_TYPE_OTHER: val = "SPOOLSS_DRIVER_FILE_TYPE_OTHER"; break;
13282         }
13283         ndr_print_enum(ndr, name, "ENUM", val, r);
13284 }
13285
13286 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverFileInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverFileInfo *r)
13287 {
13288         if (ndr_flags & NDR_SCALARS) {
13289                 NDR_CHECK(ndr_push_align(ndr, 4));
13290                 {
13291                         uint32_t _flags_save_string = ndr->flags;
13292                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13293                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->file_name));
13294                         ndr->flags = _flags_save_string;
13295                 }
13296                 NDR_CHECK(ndr_push_spoolss_DriverFileType(ndr, NDR_SCALARS, r->file_type));
13297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->file_version));
13298         }
13299         if (ndr_flags & NDR_BUFFERS) {
13300                 {
13301                         uint32_t _flags_save_string = ndr->flags;
13302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13303                         if (r->file_name) {
13304                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->file_name));
13305                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->file_name));
13306                         }
13307                         ndr->flags = _flags_save_string;
13308                 }
13309         }
13310         return NDR_ERR_SUCCESS;
13311 }
13312
13313 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverFileInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverFileInfo *r)
13314 {
13315         uint32_t _ptr_file_name;
13316         TALLOC_CTX *_mem_save_file_name_0;
13317         if (ndr_flags & NDR_SCALARS) {
13318                 NDR_CHECK(ndr_pull_align(ndr, 4));
13319                 {
13320                         uint32_t _flags_save_string = ndr->flags;
13321                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13322                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_file_name));
13323                         if (_ptr_file_name) {
13324                                 NDR_PULL_ALLOC(ndr, r->file_name);
13325                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->file_name, _ptr_file_name));
13326                         } else {
13327                                 r->file_name = NULL;
13328                         }
13329                         ndr->flags = _flags_save_string;
13330                 }
13331                 NDR_CHECK(ndr_pull_spoolss_DriverFileType(ndr, NDR_SCALARS, &r->file_type));
13332                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->file_version));
13333         }
13334         if (ndr_flags & NDR_BUFFERS) {
13335                 {
13336                         uint32_t _flags_save_string = ndr->flags;
13337                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13338                         if (r->file_name) {
13339                                 uint32_t _relative_save_offset;
13340                                 _relative_save_offset = ndr->offset;
13341                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->file_name));
13342                                 _mem_save_file_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13343                                 NDR_PULL_SET_MEM_CTX(ndr, r->file_name, 0);
13344                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->file_name));
13345                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_file_name_0, 0);
13346                                 ndr->offset = _relative_save_offset;
13347                         }
13348                         ndr->flags = _flags_save_string;
13349                 }
13350         }
13351         return NDR_ERR_SUCCESS;
13352 }
13353
13354 _PUBLIC_ void ndr_print_spoolss_DriverFileInfo(struct ndr_print *ndr, const char *name, const struct spoolss_DriverFileInfo *r)
13355 {
13356         ndr_print_struct(ndr, name, "spoolss_DriverFileInfo");
13357         ndr->depth++;
13358         ndr_print_ptr(ndr, "file_name", r->file_name);
13359         ndr->depth++;
13360         if (r->file_name) {
13361                 ndr_print_string(ndr, "file_name", r->file_name);
13362         }
13363         ndr->depth--;
13364         ndr_print_spoolss_DriverFileType(ndr, "file_type", r->file_type);
13365         ndr_print_uint32(ndr, "file_version", r->file_version);
13366         ndr->depth--;
13367 }
13368
13369 _PUBLIC_ void ndr_print_spoolss_DriverInfo101(struct ndr_print *ndr, const char *name, const struct spoolss_DriverInfo101 *r)
13370 {
13371         uint32_t cntr_file_info_1;
13372         ndr_print_struct(ndr, name, "spoolss_DriverInfo101");
13373         ndr->depth++;
13374         ndr_print_spoolss_DriverOSVersion(ndr, "version", r->version);
13375         ndr_print_ptr(ndr, "driver_name", r->driver_name);
13376         ndr->depth++;
13377         if (r->driver_name) {
13378                 ndr_print_string(ndr, "driver_name", r->driver_name);
13379         }
13380         ndr->depth--;
13381         ndr_print_ptr(ndr, "architecture", r->architecture);
13382         ndr->depth++;
13383         if (r->architecture) {
13384                 ndr_print_string(ndr, "architecture", r->architecture);
13385         }
13386         ndr->depth--;
13387         ndr_print_ptr(ndr, "file_info", r->file_info);
13388         ndr->depth++;
13389         if (r->file_info) {
13390                 ndr->print(ndr, "%s: ARRAY(%d)", "file_info", (int)r->file_count);
13391                 ndr->depth++;
13392                 for (cntr_file_info_1=0;cntr_file_info_1<r->file_count;cntr_file_info_1++) {
13393                         char *idx_1=NULL;
13394                         if (asprintf(&idx_1, "[%d]", cntr_file_info_1) != -1) {
13395                                 ndr_print_spoolss_DriverFileInfo(ndr, "file_info", &r->file_info[cntr_file_info_1]);
13396                                 free(idx_1);
13397                         }
13398                 }
13399                 ndr->depth--;
13400         }
13401         ndr->depth--;
13402         ndr_print_uint32(ndr, "file_count", r->file_count);
13403         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
13404         ndr->depth++;
13405         if (r->monitor_name) {
13406                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
13407         }
13408         ndr->depth--;
13409         ndr_print_ptr(ndr, "default_datatype", r->default_datatype);
13410         ndr->depth++;
13411         if (r->default_datatype) {
13412                 ndr_print_string(ndr, "default_datatype", r->default_datatype);
13413         }
13414         ndr->depth--;
13415         ndr_print_ptr(ndr, "previous_names", r->previous_names);
13416         ndr->depth++;
13417         if (r->previous_names) {
13418                 ndr_print_string_array(ndr, "previous_names", r->previous_names);
13419         }
13420         ndr->depth--;
13421         ndr_print_NTTIME(ndr, "driver_date", r->driver_date);
13422         ndr_print_hyper(ndr, "driver_version", r->driver_version);
13423         ndr_print_ptr(ndr, "manufacturer_name", r->manufacturer_name);
13424         ndr->depth++;
13425         if (r->manufacturer_name) {
13426                 ndr_print_string(ndr, "manufacturer_name", r->manufacturer_name);
13427         }
13428         ndr->depth--;
13429         ndr_print_ptr(ndr, "manufacturer_url", r->manufacturer_url);
13430         ndr->depth++;
13431         if (r->manufacturer_url) {
13432                 ndr_print_string(ndr, "manufacturer_url", r->manufacturer_url);
13433         }
13434         ndr->depth--;
13435         ndr_print_ptr(ndr, "hardware_id", r->hardware_id);
13436         ndr->depth++;
13437         if (r->hardware_id) {
13438                 ndr_print_string(ndr, "hardware_id", r->hardware_id);
13439         }
13440         ndr->depth--;
13441         ndr_print_ptr(ndr, "provider", r->provider);
13442         ndr->depth++;
13443         if (r->provider) {
13444                 ndr_print_string(ndr, "provider", r->provider);
13445         }
13446         ndr->depth--;
13447         ndr->depth--;
13448 }
13449
13450 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo101(const struct spoolss_DriverInfo101 *r, struct smb_iconv_convenience *ic, int flags)
13451 {
13452         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo101, ic);
13453 }
13454
13455 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverInfo *r)
13456 {
13457         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13458         if (ndr_flags & NDR_SCALARS) {
13459                 int level = ndr_push_get_switch_value(ndr, r);
13460                 switch (level) {
13461                         case 1: {
13462                                 NDR_CHECK(ndr_push_align(ndr, 4));
13463                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13464                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13465                         break; }
13466
13467                         case 2: {
13468                                 NDR_CHECK(ndr_push_align(ndr, 4));
13469                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13470                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13471                         break; }
13472
13473                         case 3: {
13474                                 NDR_CHECK(ndr_push_align(ndr, 4));
13475                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13476                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13477                         break; }
13478
13479                         case 4: {
13480                                 NDR_CHECK(ndr_push_align(ndr, 4));
13481                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13482                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13483                         break; }
13484
13485                         case 5: {
13486                                 NDR_CHECK(ndr_push_align(ndr, 4));
13487                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13488                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13489                         break; }
13490
13491                         case 6: {
13492                                 NDR_CHECK(ndr_push_align(ndr, 8));
13493                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13494                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13495                         break; }
13496
13497                         case 8: {
13498                                 NDR_CHECK(ndr_push_align(ndr, 8));
13499                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13500                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13501                         break; }
13502
13503                         case 101: {
13504                                 NDR_CHECK(ndr_push_align(ndr, 8));
13505                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13506                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13507                         break; }
13508
13509                         default: {
13510                         break; }
13511
13512                 }
13513         }
13514         if (ndr_flags & NDR_BUFFERS) {
13515                 int level = ndr_push_get_switch_value(ndr, r);
13516                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13517                 switch (level) {
13518                         case 1:
13519                                 NDR_CHECK(ndr_push_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13520                         break;
13521
13522                         case 2:
13523                                 NDR_CHECK(ndr_push_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13524                         break;
13525
13526                         case 3:
13527                                 NDR_CHECK(ndr_push_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13528                         break;
13529
13530                         case 4:
13531                                 NDR_CHECK(ndr_push_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13532                         break;
13533
13534                         case 5:
13535                                 NDR_CHECK(ndr_push_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13536                         break;
13537
13538                         case 6:
13539                                 NDR_CHECK(ndr_push_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13540                         break;
13541
13542                         case 8:
13543                                 NDR_CHECK(ndr_push_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13544                         break;
13545
13546                         case 101:
13547                                 NDR_CHECK(ndr_push_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13548                         break;
13549
13550                         default:
13551                         break;
13552
13553                 }
13554         }
13555         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13556         return NDR_ERR_SUCCESS;
13557 }
13558
13559 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverInfo *r)
13560 {
13561         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13562         int level;
13563         level = ndr_pull_get_switch_value(ndr, r);
13564         if (ndr_flags & NDR_SCALARS) {
13565                 switch (level) {
13566                         case 1: {
13567                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13568                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13569                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_SCALARS, &r->info1));
13570                         break; }
13571
13572                         case 2: {
13573                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13574                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13575                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_SCALARS, &r->info2));
13576                         break; }
13577
13578                         case 3: {
13579                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13580                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13581                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_SCALARS, &r->info3));
13582                         break; }
13583
13584                         case 4: {
13585                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13586                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13587                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_SCALARS, &r->info4));
13588                         break; }
13589
13590                         case 5: {
13591                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13592                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13593                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_SCALARS, &r->info5));
13594                         break; }
13595
13596                         case 6: {
13597                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13598                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13599                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_SCALARS, &r->info6));
13600                         break; }
13601
13602                         case 8: {
13603                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13604                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13605                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_SCALARS, &r->info8));
13606                         break; }
13607
13608                         case 101: {
13609                                 NDR_CHECK(ndr_pull_align(ndr, 8));
13610                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13611                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_SCALARS, &r->info101));
13612                         break; }
13613
13614                         default: {
13615                         break; }
13616
13617                 }
13618         }
13619         if (ndr_flags & NDR_BUFFERS) {
13620                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13621                 switch (level) {
13622                         case 1:
13623                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo1(ndr, NDR_BUFFERS, &r->info1));
13624                         break;
13625
13626                         case 2:
13627                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo2(ndr, NDR_BUFFERS, &r->info2));
13628                         break;
13629
13630                         case 3:
13631                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo3(ndr, NDR_BUFFERS, &r->info3));
13632                         break;
13633
13634                         case 4:
13635                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo4(ndr, NDR_BUFFERS, &r->info4));
13636                         break;
13637
13638                         case 5:
13639                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo5(ndr, NDR_BUFFERS, &r->info5));
13640                         break;
13641
13642                         case 6:
13643                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo6(ndr, NDR_BUFFERS, &r->info6));
13644                         break;
13645
13646                         case 8:
13647                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo8(ndr, NDR_BUFFERS, &r->info8));
13648                         break;
13649
13650                         case 101:
13651                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo101(ndr, NDR_BUFFERS, &r->info101));
13652                         break;
13653
13654                         default:
13655                         break;
13656
13657                 }
13658         }
13659         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13660         return NDR_ERR_SUCCESS;
13661 }
13662
13663 _PUBLIC_ void ndr_print_spoolss_DriverInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverInfo *r)
13664 {
13665         int level;
13666         level = ndr_print_get_switch_value(ndr, r);
13667         ndr_print_union(ndr, name, level, "spoolss_DriverInfo");
13668         switch (level) {
13669                 case 1:
13670                         ndr_print_spoolss_DriverInfo1(ndr, "info1", &r->info1);
13671                 break;
13672
13673                 case 2:
13674                         ndr_print_spoolss_DriverInfo2(ndr, "info2", &r->info2);
13675                 break;
13676
13677                 case 3:
13678                         ndr_print_spoolss_DriverInfo3(ndr, "info3", &r->info3);
13679                 break;
13680
13681                 case 4:
13682                         ndr_print_spoolss_DriverInfo4(ndr, "info4", &r->info4);
13683                 break;
13684
13685                 case 5:
13686                         ndr_print_spoolss_DriverInfo5(ndr, "info5", &r->info5);
13687                 break;
13688
13689                 case 6:
13690                         ndr_print_spoolss_DriverInfo6(ndr, "info6", &r->info6);
13691                 break;
13692
13693                 case 8:
13694                         ndr_print_spoolss_DriverInfo8(ndr, "info8", &r->info8);
13695                 break;
13696
13697                 case 101:
13698                         ndr_print_spoolss_DriverInfo101(ndr, "info101", &r->info101);
13699                 break;
13700
13701                 default:
13702                 break;
13703
13704         }
13705 }
13706
13707 _PUBLIC_ size_t ndr_size_spoolss_DriverInfo(const union spoolss_DriverInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13708 {
13709         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverInfo, ic);
13710 }
13711
13712 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DriverDirectoryInfo1 *r)
13713 {
13714         if (ndr_flags & NDR_SCALARS) {
13715                 NDR_CHECK(ndr_push_align(ndr, 4));
13716                 {
13717                         uint32_t _flags_save_string = ndr->flags;
13718                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13719                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
13720                         ndr->flags = _flags_save_string;
13721                 }
13722         }
13723         if (ndr_flags & NDR_BUFFERS) {
13724         }
13725         return NDR_ERR_SUCCESS;
13726 }
13727
13728 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DriverDirectoryInfo1 *r)
13729 {
13730         if (ndr_flags & NDR_SCALARS) {
13731                 NDR_CHECK(ndr_pull_align(ndr, 4));
13732                 {
13733                         uint32_t _flags_save_string = ndr->flags;
13734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13735                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
13736                         ndr->flags = _flags_save_string;
13737                 }
13738         }
13739         if (ndr_flags & NDR_BUFFERS) {
13740         }
13741         return NDR_ERR_SUCCESS;
13742 }
13743
13744 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DriverDirectoryInfo1 *r)
13745 {
13746         ndr_print_struct(ndr, name, "spoolss_DriverDirectoryInfo1");
13747         ndr->depth++;
13748         ndr_print_string(ndr, "directory_name", r->directory_name);
13749         ndr->depth--;
13750 }
13751
13752 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo1(const struct spoolss_DriverDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13753 {
13754         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo1, ic);
13755 }
13756
13757 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DriverDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DriverDirectoryInfo *r)
13758 {
13759         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13760         if (ndr_flags & NDR_SCALARS) {
13761                 int level = ndr_push_get_switch_value(ndr, r);
13762                 switch (level) {
13763                         case 1: {
13764                                 NDR_CHECK(ndr_push_align(ndr, 4));
13765                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13766                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13767                         break; }
13768
13769                         default: {
13770                                 NDR_CHECK(ndr_push_align(ndr, 4));
13771                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13772                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13773                         break; }
13774
13775                 }
13776         }
13777         if (ndr_flags & NDR_BUFFERS) {
13778                 int level = ndr_push_get_switch_value(ndr, r);
13779                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13780                 switch (level) {
13781                         case 1:
13782                         break;
13783
13784                         default:
13785                         break;
13786
13787                 }
13788         }
13789         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13790         return NDR_ERR_SUCCESS;
13791 }
13792
13793 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DriverDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DriverDirectoryInfo *r)
13794 {
13795         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13796         int level;
13797         level = ndr_pull_get_switch_value(ndr, r);
13798         if (ndr_flags & NDR_SCALARS) {
13799                 switch (level) {
13800                         case 1: {
13801                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13802                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13803                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13804                         break; }
13805
13806                         default: {
13807                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13808                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13809                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
13810                         break; }
13811
13812                 }
13813         }
13814         if (ndr_flags & NDR_BUFFERS) {
13815                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13816                 switch (level) {
13817                         case 1:
13818                         break;
13819
13820                         default:
13821                         break;
13822
13823                 }
13824         }
13825         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13826         return NDR_ERR_SUCCESS;
13827 }
13828
13829 _PUBLIC_ void ndr_print_spoolss_DriverDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_DriverDirectoryInfo *r)
13830 {
13831         int level;
13832         level = ndr_print_get_switch_value(ndr, r);
13833         ndr_print_union(ndr, name, level, "spoolss_DriverDirectoryInfo");
13834         switch (level) {
13835                 case 1:
13836                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13837                 break;
13838
13839                 default:
13840                         ndr_print_spoolss_DriverDirectoryInfo1(ndr, "info1", &r->info1);
13841                 break;
13842
13843         }
13844 }
13845
13846 _PUBLIC_ size_t ndr_size_spoolss_DriverDirectoryInfo(const union spoolss_DriverDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
13847 {
13848         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_DriverDirectoryInfo, ic);
13849 }
13850
13851 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorInfo1 *r)
13852 {
13853         if (ndr_flags & NDR_SCALARS) {
13854                 NDR_CHECK(ndr_push_align(ndr, 4));
13855                 {
13856                         uint32_t _flags_save_string = ndr->flags;
13857                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13858                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->print_processor_name));
13859                         ndr->flags = _flags_save_string;
13860                 }
13861         }
13862         if (ndr_flags & NDR_BUFFERS) {
13863                 {
13864                         uint32_t _flags_save_string = ndr->flags;
13865                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13866                         if (r->print_processor_name) {
13867                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->print_processor_name));
13868                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->print_processor_name));
13869                         }
13870                         ndr->flags = _flags_save_string;
13871                 }
13872         }
13873         return NDR_ERR_SUCCESS;
13874 }
13875
13876 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorInfo1 *r)
13877 {
13878         uint32_t _ptr_print_processor_name;
13879         TALLOC_CTX *_mem_save_print_processor_name_0;
13880         if (ndr_flags & NDR_SCALARS) {
13881                 NDR_CHECK(ndr_pull_align(ndr, 4));
13882                 {
13883                         uint32_t _flags_save_string = ndr->flags;
13884                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13885                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
13886                         if (_ptr_print_processor_name) {
13887                                 NDR_PULL_ALLOC(ndr, r->print_processor_name);
13888                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->print_processor_name, _ptr_print_processor_name));
13889                         } else {
13890                                 r->print_processor_name = NULL;
13891                         }
13892                         ndr->flags = _flags_save_string;
13893                 }
13894         }
13895         if (ndr_flags & NDR_BUFFERS) {
13896                 {
13897                         uint32_t _flags_save_string = ndr->flags;
13898                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
13899                         if (r->print_processor_name) {
13900                                 uint32_t _relative_save_offset;
13901                                 _relative_save_offset = ndr->offset;
13902                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->print_processor_name));
13903                                 _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
13904                                 NDR_PULL_SET_MEM_CTX(ndr, r->print_processor_name, 0);
13905                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->print_processor_name));
13906                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
13907                                 ndr->offset = _relative_save_offset;
13908                         }
13909                         ndr->flags = _flags_save_string;
13910                 }
13911         }
13912         return NDR_ERR_SUCCESS;
13913 }
13914
13915 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorInfo1 *r)
13916 {
13917         ndr_print_struct(ndr, name, "spoolss_PrintProcessorInfo1");
13918         ndr->depth++;
13919         ndr_print_ptr(ndr, "print_processor_name", r->print_processor_name);
13920         ndr->depth++;
13921         if (r->print_processor_name) {
13922                 ndr_print_string(ndr, "print_processor_name", r->print_processor_name);
13923         }
13924         ndr->depth--;
13925         ndr->depth--;
13926 }
13927
13928 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorInfo1(const struct spoolss_PrintProcessorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
13929 {
13930         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorInfo1, ic);
13931 }
13932
13933 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorInfo *r)
13934 {
13935         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
13936         if (ndr_flags & NDR_SCALARS) {
13937                 int level = ndr_push_get_switch_value(ndr, r);
13938                 switch (level) {
13939                         case 1: {
13940                                 NDR_CHECK(ndr_push_align(ndr, 4));
13941                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
13942                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13943                         break; }
13944
13945                         default: {
13946                         break; }
13947
13948                 }
13949         }
13950         if (ndr_flags & NDR_BUFFERS) {
13951                 int level = ndr_push_get_switch_value(ndr, r);
13952                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
13953                 switch (level) {
13954                         case 1:
13955                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13956                         break;
13957
13958                         default:
13959                         break;
13960
13961                 }
13962         }
13963         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
13964         return NDR_ERR_SUCCESS;
13965 }
13966
13967 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorInfo *r)
13968 {
13969         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
13970         int level;
13971         level = ndr_pull_get_switch_value(ndr, r);
13972         if (ndr_flags & NDR_SCALARS) {
13973                 switch (level) {
13974                         case 1: {
13975                                 NDR_CHECK(ndr_pull_align(ndr, 4));
13976                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
13977                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_SCALARS, &r->info1));
13978                         break; }
13979
13980                         default: {
13981                         break; }
13982
13983                 }
13984         }
13985         if (ndr_flags & NDR_BUFFERS) {
13986                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
13987                 switch (level) {
13988                         case 1:
13989                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo1(ndr, NDR_BUFFERS, &r->info1));
13990                         break;
13991
13992                         default:
13993                         break;
13994
13995                 }
13996         }
13997         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
13998         return NDR_ERR_SUCCESS;
13999 }
14000
14001 _PUBLIC_ void ndr_print_spoolss_PrintProcessorInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorInfo *r)
14002 {
14003         int level;
14004         level = ndr_print_get_switch_value(ndr, r);
14005         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorInfo");
14006         switch (level) {
14007                 case 1:
14008                         ndr_print_spoolss_PrintProcessorInfo1(ndr, "info1", &r->info1);
14009                 break;
14010
14011                 default:
14012                 break;
14013
14014         }
14015 }
14016
14017 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14018 {
14019         if (ndr_flags & NDR_SCALARS) {
14020                 NDR_CHECK(ndr_push_align(ndr, 4));
14021                 {
14022                         uint32_t _flags_save_string = ndr->flags;
14023                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14024                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->directory_name));
14025                         ndr->flags = _flags_save_string;
14026                 }
14027         }
14028         if (ndr_flags & NDR_BUFFERS) {
14029         }
14030         return NDR_ERR_SUCCESS;
14031 }
14032
14033 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcessorDirectoryInfo1 *r)
14034 {
14035         if (ndr_flags & NDR_SCALARS) {
14036                 NDR_CHECK(ndr_pull_align(ndr, 4));
14037                 {
14038                         uint32_t _flags_save_string = ndr->flags;
14039                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14040                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->directory_name));
14041                         ndr->flags = _flags_save_string;
14042                 }
14043         }
14044         if (ndr_flags & NDR_BUFFERS) {
14045         }
14046         return NDR_ERR_SUCCESS;
14047 }
14048
14049 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcessorDirectoryInfo1 *r)
14050 {
14051         ndr_print_struct(ndr, name, "spoolss_PrintProcessorDirectoryInfo1");
14052         ndr->depth++;
14053         ndr_print_string(ndr, "directory_name", r->directory_name);
14054         ndr->depth--;
14055 }
14056
14057 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo1(const struct spoolss_PrintProcessorDirectoryInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14058 {
14059         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo1, ic);
14060 }
14061
14062 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcessorDirectoryInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcessorDirectoryInfo *r)
14063 {
14064         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
14065         if (ndr_flags & NDR_SCALARS) {
14066                 int level = ndr_push_get_switch_value(ndr, r);
14067                 switch (level) {
14068                         case 1: {
14069                                 NDR_CHECK(ndr_push_align(ndr, 4));
14070                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14071                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14072                         break; }
14073
14074                         default: {
14075                                 NDR_CHECK(ndr_push_align(ndr, 4));
14076                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
14077                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14078                         break; }
14079
14080                 }
14081         }
14082         if (ndr_flags & NDR_BUFFERS) {
14083                 int level = ndr_push_get_switch_value(ndr, r);
14084                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
14085                 switch (level) {
14086                         case 1:
14087                         break;
14088
14089                         default:
14090                         break;
14091
14092                 }
14093         }
14094         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
14095         return NDR_ERR_SUCCESS;
14096 }
14097
14098 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcessorDirectoryInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcessorDirectoryInfo *r)
14099 {
14100         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
14101         int level;
14102         level = ndr_pull_get_switch_value(ndr, r);
14103         if (ndr_flags & NDR_SCALARS) {
14104                 switch (level) {
14105                         case 1: {
14106                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14107                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14108                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14109                         break; }
14110
14111                         default: {
14112                                 NDR_CHECK(ndr_pull_align(ndr, 4));
14113                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
14114                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo1(ndr, NDR_SCALARS, &r->info1));
14115                         break; }
14116
14117                 }
14118         }
14119         if (ndr_flags & NDR_BUFFERS) {
14120                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
14121                 switch (level) {
14122                         case 1:
14123                         break;
14124
14125                         default:
14126                         break;
14127
14128                 }
14129         }
14130         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
14131         return NDR_ERR_SUCCESS;
14132 }
14133
14134 _PUBLIC_ void ndr_print_spoolss_PrintProcessorDirectoryInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcessorDirectoryInfo *r)
14135 {
14136         int level;
14137         level = ndr_print_get_switch_value(ndr, r);
14138         ndr_print_union(ndr, name, level, "spoolss_PrintProcessorDirectoryInfo");
14139         switch (level) {
14140                 case 1:
14141                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14142                 break;
14143
14144                 default:
14145                         ndr_print_spoolss_PrintProcessorDirectoryInfo1(ndr, "info1", &r->info1);
14146                 break;
14147
14148         }
14149 }
14150
14151 _PUBLIC_ size_t ndr_size_spoolss_PrintProcessorDirectoryInfo(const union spoolss_PrintProcessorDirectoryInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14152 {
14153         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcessorDirectoryInfo, ic);
14154 }
14155
14156 static enum ndr_err_code ndr_push_spoolss_DocumentInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_DocumentInfo1 *r)
14157 {
14158         if (ndr_flags & NDR_SCALARS) {
14159                 NDR_CHECK(ndr_push_align(ndr, 4));
14160                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->document_name));
14161                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->output_file));
14162                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->datatype));
14163         }
14164         if (ndr_flags & NDR_BUFFERS) {
14165                 if (r->document_name) {
14166                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14168                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->document_name, CH_UTF16)));
14169                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->document_name, ndr_charset_length(r->document_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14170                 }
14171                 if (r->output_file) {
14172                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14173                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14174                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->output_file, CH_UTF16)));
14175                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->output_file, ndr_charset_length(r->output_file, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14176                 }
14177                 if (r->datatype) {
14178                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14179                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
14180                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->datatype, CH_UTF16)));
14181                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->datatype, ndr_charset_length(r->datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
14182                 }
14183         }
14184         return NDR_ERR_SUCCESS;
14185 }
14186
14187 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_DocumentInfo1 *r)
14188 {
14189         uint32_t _ptr_document_name;
14190         TALLOC_CTX *_mem_save_document_name_0;
14191         uint32_t _ptr_output_file;
14192         TALLOC_CTX *_mem_save_output_file_0;
14193         uint32_t _ptr_datatype;
14194         TALLOC_CTX *_mem_save_datatype_0;
14195         if (ndr_flags & NDR_SCALARS) {
14196                 NDR_CHECK(ndr_pull_align(ndr, 4));
14197                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_document_name));
14198                 if (_ptr_document_name) {
14199                         NDR_PULL_ALLOC(ndr, r->document_name);
14200                 } else {
14201                         r->document_name = NULL;
14202                 }
14203                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_output_file));
14204                 if (_ptr_output_file) {
14205                         NDR_PULL_ALLOC(ndr, r->output_file);
14206                 } else {
14207                         r->output_file = NULL;
14208                 }
14209                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
14210                 if (_ptr_datatype) {
14211                         NDR_PULL_ALLOC(ndr, r->datatype);
14212                 } else {
14213                         r->datatype = NULL;
14214                 }
14215         }
14216         if (ndr_flags & NDR_BUFFERS) {
14217                 if (r->document_name) {
14218                         _mem_save_document_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14219                         NDR_PULL_SET_MEM_CTX(ndr, r->document_name, 0);
14220                         NDR_CHECK(ndr_pull_array_size(ndr, &r->document_name));
14221                         NDR_CHECK(ndr_pull_array_length(ndr, &r->document_name));
14222                         if (ndr_get_array_length(ndr, &r->document_name) > ndr_get_array_size(ndr, &r->document_name)) {
14223                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->document_name), ndr_get_array_length(ndr, &r->document_name));
14224                         }
14225                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t)));
14226                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->document_name, ndr_get_array_length(ndr, &r->document_name), sizeof(uint16_t), CH_UTF16));
14227                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_document_name_0, 0);
14228                 }
14229                 if (r->output_file) {
14230                         _mem_save_output_file_0 = NDR_PULL_GET_MEM_CTX(ndr);
14231                         NDR_PULL_SET_MEM_CTX(ndr, r->output_file, 0);
14232                         NDR_CHECK(ndr_pull_array_size(ndr, &r->output_file));
14233                         NDR_CHECK(ndr_pull_array_length(ndr, &r->output_file));
14234                         if (ndr_get_array_length(ndr, &r->output_file) > ndr_get_array_size(ndr, &r->output_file)) {
14235                                 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));
14236                         }
14237                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t)));
14238                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->output_file, ndr_get_array_length(ndr, &r->output_file), sizeof(uint16_t), CH_UTF16));
14239                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_output_file_0, 0);
14240                 }
14241                 if (r->datatype) {
14242                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
14243                         NDR_PULL_SET_MEM_CTX(ndr, r->datatype, 0);
14244                         NDR_CHECK(ndr_pull_array_size(ndr, &r->datatype));
14245                         NDR_CHECK(ndr_pull_array_length(ndr, &r->datatype));
14246                         if (ndr_get_array_length(ndr, &r->datatype) > ndr_get_array_size(ndr, &r->datatype)) {
14247                                 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));
14248                         }
14249                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t)));
14250                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->datatype, ndr_get_array_length(ndr, &r->datatype), sizeof(uint16_t), CH_UTF16));
14251                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
14252                 }
14253         }
14254         return NDR_ERR_SUCCESS;
14255 }
14256
14257 _PUBLIC_ void ndr_print_spoolss_DocumentInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_DocumentInfo1 *r)
14258 {
14259         ndr_print_struct(ndr, name, "spoolss_DocumentInfo1");
14260         ndr->depth++;
14261         ndr_print_ptr(ndr, "document_name", r->document_name);
14262         ndr->depth++;
14263         if (r->document_name) {
14264                 ndr_print_string(ndr, "document_name", r->document_name);
14265         }
14266         ndr->depth--;
14267         ndr_print_ptr(ndr, "output_file", r->output_file);
14268         ndr->depth++;
14269         if (r->output_file) {
14270                 ndr_print_string(ndr, "output_file", r->output_file);
14271         }
14272         ndr->depth--;
14273         ndr_print_ptr(ndr, "datatype", r->datatype);
14274         ndr->depth++;
14275         if (r->datatype) {
14276                 ndr_print_string(ndr, "datatype", r->datatype);
14277         }
14278         ndr->depth--;
14279         ndr->depth--;
14280 }
14281
14282 static enum ndr_err_code ndr_push_spoolss_DocumentInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_DocumentInfo *r)
14283 {
14284         if (ndr_flags & NDR_SCALARS) {
14285                 int level = ndr_push_get_switch_value(ndr, r);
14286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
14287                 switch (level) {
14288                         case 1: {
14289                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
14290                         break; }
14291
14292                         case 2: {
14293                         break; }
14294
14295                         case 3: {
14296                         break; }
14297
14298                         default: {
14299                         break; }
14300
14301                 }
14302         }
14303         if (ndr_flags & NDR_BUFFERS) {
14304                 int level = ndr_push_get_switch_value(ndr, r);
14305                 switch (level) {
14306                         case 1:
14307                                 if (r->info1) {
14308                                         NDR_CHECK(ndr_push_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14309                                 }
14310                         break;
14311
14312                         case 2:
14313                         break;
14314
14315                         case 3:
14316                         break;
14317
14318                         default:
14319                         break;
14320
14321                 }
14322         }
14323         return NDR_ERR_SUCCESS;
14324 }
14325
14326 static enum ndr_err_code ndr_pull_spoolss_DocumentInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_DocumentInfo *r)
14327 {
14328         int level;
14329         uint32_t _level;
14330         TALLOC_CTX *_mem_save_info1_0;
14331         level = ndr_pull_get_switch_value(ndr, r);
14332         if (ndr_flags & NDR_SCALARS) {
14333                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
14334                 if (_level != level) {
14335                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
14336                 }
14337                 switch (level) {
14338                         case 1: {
14339                                 uint32_t _ptr_info1;
14340                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
14341                                 if (_ptr_info1) {
14342                                         NDR_PULL_ALLOC(ndr, r->info1);
14343                                 } else {
14344                                         r->info1 = NULL;
14345                                 }
14346                         break; }
14347
14348                         case 2: {
14349                         break; }
14350
14351                         case 3: {
14352                         break; }
14353
14354                         default: {
14355                         break; }
14356
14357                 }
14358         }
14359         if (ndr_flags & NDR_BUFFERS) {
14360                 switch (level) {
14361                         case 1:
14362                                 if (r->info1) {
14363                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
14364                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
14365                                         NDR_CHECK(ndr_pull_spoolss_DocumentInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
14366                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
14367                                 }
14368                         break;
14369
14370                         case 2:
14371                         break;
14372
14373                         case 3:
14374                         break;
14375
14376                         default:
14377                         break;
14378
14379                 }
14380         }
14381         return NDR_ERR_SUCCESS;
14382 }
14383
14384 _PUBLIC_ void ndr_print_spoolss_DocumentInfo(struct ndr_print *ndr, const char *name, const union spoolss_DocumentInfo *r)
14385 {
14386         int level;
14387         level = ndr_print_get_switch_value(ndr, r);
14388         ndr_print_union(ndr, name, level, "spoolss_DocumentInfo");
14389         switch (level) {
14390                 case 1:
14391                         ndr_print_ptr(ndr, "info1", r->info1);
14392                         ndr->depth++;
14393                         if (r->info1) {
14394                                 ndr_print_spoolss_DocumentInfo1(ndr, "info1", r->info1);
14395                         }
14396                         ndr->depth--;
14397                 break;
14398
14399                 case 2:
14400                 break;
14401
14402                 case 3:
14403                 break;
14404
14405                 default:
14406                 break;
14407
14408         }
14409 }
14410
14411 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersion(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersion *r)
14412 {
14413         if (ndr_flags & NDR_SCALARS) {
14414                 NDR_CHECK(ndr_push_align(ndr, 4));
14415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersion(r, ndr->iconv_convenience, ndr->flags)));
14416                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14417                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14418                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14419                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14420                 {
14421                         uint32_t _flags_save_string = ndr->flags;
14422                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14423                         {
14424                                 struct ndr_push *_ndr_extra_string;
14425                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14426                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14427                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14428                         }
14429                         ndr->flags = _flags_save_string;
14430                 }
14431         }
14432         if (ndr_flags & NDR_BUFFERS) {
14433         }
14434         return NDR_ERR_SUCCESS;
14435 }
14436
14437 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersion(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersion *r)
14438 {
14439         if (ndr_flags & NDR_SCALARS) {
14440                 NDR_CHECK(ndr_pull_align(ndr, 4));
14441                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14442                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14444                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown));
14446                 {
14447                         uint32_t _flags_save_string = ndr->flags;
14448                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14449                         {
14450                                 struct ndr_pull *_ndr_extra_string;
14451                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14452                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14453                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14454                         }
14455                         ndr->flags = _flags_save_string;
14456                 }
14457         }
14458         if (ndr_flags & NDR_BUFFERS) {
14459         }
14460         return NDR_ERR_SUCCESS;
14461 }
14462
14463 _PUBLIC_ void ndr_print_spoolss_OSVersion(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersion *r)
14464 {
14465         ndr_print_struct(ndr, name, "spoolss_OSVersion");
14466         ndr->depth++;
14467         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);
14468         ndr_print_uint32(ndr, "major", r->major);
14469         ndr_print_uint32(ndr, "minor", r->minor);
14470         ndr_print_uint32(ndr, "build", r->build);
14471         ndr_print_uint32(ndr, "unknown", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown);
14472         ndr_print_string(ndr, "extra_string", r->extra_string);
14473         ndr->depth--;
14474 }
14475
14476 _PUBLIC_ size_t ndr_size_spoolss_OSVersion(const struct spoolss_OSVersion *r, struct smb_iconv_convenience *ic, int flags)
14477 {
14478         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersion, ic);
14479 }
14480
14481 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OSVersionEx(struct ndr_push *ndr, int ndr_flags, const struct spoolss_OSVersionEx *r)
14482 {
14483         if (ndr_flags & NDR_SCALARS) {
14484                 NDR_CHECK(ndr_push_align(ndr, 4));
14485                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_OSVersionEx(r, ndr->iconv_convenience, ndr->flags)));
14486                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->major));
14487                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->minor));
14488                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
14489                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
14490                 {
14491                         uint32_t _flags_save_string = ndr->flags;
14492                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14493                         {
14494                                 struct ndr_push *_ndr_extra_string;
14495                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14496                                 NDR_CHECK(ndr_push_string(_ndr_extra_string, NDR_SCALARS, r->extra_string));
14497                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14498                         }
14499                         ndr->flags = _flags_save_string;
14500                 }
14501                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown2));
14502                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->unknown3));
14503         }
14504         if (ndr_flags & NDR_BUFFERS) {
14505         }
14506         return NDR_ERR_SUCCESS;
14507 }
14508
14509 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OSVersionEx(struct ndr_pull *ndr, int ndr_flags, struct spoolss_OSVersionEx *r)
14510 {
14511         if (ndr_flags & NDR_SCALARS) {
14512                 NDR_CHECK(ndr_pull_align(ndr, 4));
14513                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->_ndr_size));
14514                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->major));
14515                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->minor));
14516                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
14517                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown1));
14518                 {
14519                         uint32_t _flags_save_string = ndr->flags;
14520                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14521                         {
14522                                 struct ndr_pull *_ndr_extra_string;
14523                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_extra_string, 0, 256));
14524                                 NDR_CHECK(ndr_pull_string(_ndr_extra_string, NDR_SCALARS, &r->extra_string));
14525                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_extra_string, 0, 256));
14526                         }
14527                         ndr->flags = _flags_save_string;
14528                 }
14529                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown2));
14530                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->unknown3));
14531         }
14532         if (ndr_flags & NDR_BUFFERS) {
14533         }
14534         return NDR_ERR_SUCCESS;
14535 }
14536
14537 _PUBLIC_ void ndr_print_spoolss_OSVersionEx(struct ndr_print *ndr, const char *name, const struct spoolss_OSVersionEx *r)
14538 {
14539         ndr_print_struct(ndr, name, "spoolss_OSVersionEx");
14540         ndr->depth++;
14541         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);
14542         ndr_print_uint32(ndr, "major", r->major);
14543         ndr_print_uint32(ndr, "minor", r->minor);
14544         ndr_print_uint32(ndr, "build", r->build);
14545         ndr_print_uint32(ndr, "unknown1", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->unknown1);
14546         ndr_print_string(ndr, "extra_string", r->extra_string);
14547         ndr_print_uint32(ndr, "unknown2", r->unknown2);
14548         ndr_print_uint32(ndr, "unknown3", r->unknown3);
14549         ndr->depth--;
14550 }
14551
14552 _PUBLIC_ size_t ndr_size_spoolss_OSVersionEx(const struct spoolss_OSVersionEx *r, struct smb_iconv_convenience *ic, int flags)
14553 {
14554         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_OSVersionEx, ic);
14555 }
14556
14557 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterData(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrinterData *r)
14558 {
14559         if (ndr_flags & NDR_SCALARS) {
14560                 int level = ndr_push_get_switch_value(ndr, r);
14561                 switch (level) {
14562                         case REG_NONE: {
14563                         break; }
14564
14565                         case REG_SZ: {
14566                                 {
14567                                         uint32_t _flags_save_string = ndr->flags;
14568                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14569                                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->string));
14570                                         ndr->flags = _flags_save_string;
14571                                 }
14572                         break; }
14573
14574                         case REG_BINARY: {
14575                                 {
14576                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14577                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14578                                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->binary));
14579                                         ndr->flags = _flags_save_DATA_BLOB;
14580                                 }
14581                         break; }
14582
14583                         case REG_DWORD: {
14584                                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->value));
14585                         break; }
14586
14587                         case REG_MULTI_SZ: {
14588                                 {
14589                                         uint32_t _flags_save_string_array = ndr->flags;
14590                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14591                                         NDR_CHECK(ndr_push_string_array(ndr, NDR_SCALARS, r->string_array));
14592                                         ndr->flags = _flags_save_string_array;
14593                                 }
14594                         break; }
14595
14596                         default: {
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->data));
14601                                         ndr->flags = _flags_save_DATA_BLOB;
14602                                 }
14603                         break; }
14604
14605                 }
14606         }
14607         if (ndr_flags & NDR_BUFFERS) {
14608                 int level = ndr_push_get_switch_value(ndr, r);
14609                 switch (level) {
14610                         case REG_NONE:
14611                         break;
14612
14613                         case REG_SZ:
14614                         break;
14615
14616                         case REG_BINARY:
14617                         break;
14618
14619                         case REG_DWORD:
14620                         break;
14621
14622                         case REG_MULTI_SZ:
14623                         break;
14624
14625                         default:
14626                         break;
14627
14628                 }
14629         }
14630         return NDR_ERR_SUCCESS;
14631 }
14632
14633 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterData(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrinterData *r)
14634 {
14635         int level;
14636         level = ndr_pull_get_switch_value(ndr, r);
14637         if (ndr_flags & NDR_SCALARS) {
14638                 switch (level) {
14639                         case REG_NONE: {
14640                         break; }
14641
14642                         case REG_SZ: {
14643                                 {
14644                                         uint32_t _flags_save_string = ndr->flags;
14645                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14646                                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->string));
14647                                         ndr->flags = _flags_save_string;
14648                                 }
14649                         break; }
14650
14651                         case REG_BINARY: {
14652                                 {
14653                                         uint32_t _flags_save_DATA_BLOB = ndr->flags;
14654                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_REMAINING);
14655                                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->binary));
14656                                         ndr->flags = _flags_save_DATA_BLOB;
14657                                 }
14658                         break; }
14659
14660                         case REG_DWORD: {
14661                                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value));
14662                         break; }
14663
14664                         case REG_MULTI_SZ: {
14665                                 {
14666                                         uint32_t _flags_save_string_array = ndr->flags;
14667                                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14668                                         NDR_CHECK(ndr_pull_string_array(ndr, NDR_SCALARS, &r->string_array));
14669                                         ndr->flags = _flags_save_string_array;
14670                                 }
14671                         break; }
14672
14673                         default: {
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->data));
14678                                         ndr->flags = _flags_save_DATA_BLOB;
14679                                 }
14680                         break; }
14681
14682                 }
14683         }
14684         if (ndr_flags & NDR_BUFFERS) {
14685                 switch (level) {
14686                         case REG_NONE:
14687                         break;
14688
14689                         case REG_SZ:
14690                         break;
14691
14692                         case REG_BINARY:
14693                         break;
14694
14695                         case REG_DWORD:
14696                         break;
14697
14698                         case REG_MULTI_SZ:
14699                         break;
14700
14701                         default:
14702                         break;
14703
14704                 }
14705         }
14706         return NDR_ERR_SUCCESS;
14707 }
14708
14709 _PUBLIC_ void ndr_print_spoolss_PrinterData(struct ndr_print *ndr, const char *name, const union spoolss_PrinterData *r)
14710 {
14711         int level;
14712         level = ndr_print_get_switch_value(ndr, r);
14713         ndr_print_union(ndr, name, level, "spoolss_PrinterData");
14714         switch (level) {
14715                 case REG_NONE:
14716                 break;
14717
14718                 case REG_SZ:
14719                         ndr_print_string(ndr, "string", r->string);
14720                 break;
14721
14722                 case REG_BINARY:
14723                         ndr_print_DATA_BLOB(ndr, "binary", r->binary);
14724                 break;
14725
14726                 case REG_DWORD:
14727                         ndr_print_uint32(ndr, "value", r->value);
14728                 break;
14729
14730                 case REG_MULTI_SZ:
14731                         ndr_print_string_array(ndr, "string_array", r->string_array);
14732                 break;
14733
14734                 default:
14735                         ndr_print_DATA_BLOB(ndr, "data", r->data);
14736                 break;
14737
14738         }
14739 }
14740
14741 _PUBLIC_ size_t ndr_size_spoolss_PrinterData(const union spoolss_PrinterData *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
14742 {
14743         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterData, ic);
14744 }
14745
14746 static enum ndr_err_code ndr_push_spoolss_FormFlags(struct ndr_push *ndr, int ndr_flags, enum spoolss_FormFlags r)
14747 {
14748         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14749         return NDR_ERR_SUCCESS;
14750 }
14751
14752 static enum ndr_err_code ndr_pull_spoolss_FormFlags(struct ndr_pull *ndr, int ndr_flags, enum spoolss_FormFlags *r)
14753 {
14754         uint32_t v;
14755         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14756         *r = v;
14757         return NDR_ERR_SUCCESS;
14758 }
14759
14760 _PUBLIC_ void ndr_print_spoolss_FormFlags(struct ndr_print *ndr, const char *name, enum spoolss_FormFlags r)
14761 {
14762         const char *val = NULL;
14763
14764         switch (r) {
14765                 case SPOOLSS_FORM_USER: val = "SPOOLSS_FORM_USER"; break;
14766                 case SPOOLSS_FORM_BUILTIN: val = "SPOOLSS_FORM_BUILTIN"; break;
14767                 case SPOOLSS_FORM_PRINTER: val = "SPOOLSS_FORM_PRINTER"; break;
14768         }
14769         ndr_print_enum(ndr, name, "ENUM", val, r);
14770 }
14771
14772 static enum ndr_err_code ndr_push_spoolss_FormSize(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormSize *r)
14773 {
14774         if (ndr_flags & NDR_SCALARS) {
14775                 NDR_CHECK(ndr_push_align(ndr, 4));
14776                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->width));
14777                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->height));
14778         }
14779         if (ndr_flags & NDR_BUFFERS) {
14780         }
14781         return NDR_ERR_SUCCESS;
14782 }
14783
14784 static enum ndr_err_code ndr_pull_spoolss_FormSize(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormSize *r)
14785 {
14786         if (ndr_flags & NDR_SCALARS) {
14787                 NDR_CHECK(ndr_pull_align(ndr, 4));
14788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->width));
14789                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->height));
14790         }
14791         if (ndr_flags & NDR_BUFFERS) {
14792         }
14793         return NDR_ERR_SUCCESS;
14794 }
14795
14796 _PUBLIC_ void ndr_print_spoolss_FormSize(struct ndr_print *ndr, const char *name, const struct spoolss_FormSize *r)
14797 {
14798         ndr_print_struct(ndr, name, "spoolss_FormSize");
14799         ndr->depth++;
14800         ndr_print_uint32(ndr, "width", r->width);
14801         ndr_print_uint32(ndr, "height", r->height);
14802         ndr->depth--;
14803 }
14804
14805 static enum ndr_err_code ndr_push_spoolss_FormArea(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormArea *r)
14806 {
14807         if (ndr_flags & NDR_SCALARS) {
14808                 NDR_CHECK(ndr_push_align(ndr, 4));
14809                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->left));
14810                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->top));
14811                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->right));
14812                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->bottom));
14813         }
14814         if (ndr_flags & NDR_BUFFERS) {
14815         }
14816         return NDR_ERR_SUCCESS;
14817 }
14818
14819 static enum ndr_err_code ndr_pull_spoolss_FormArea(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormArea *r)
14820 {
14821         if (ndr_flags & NDR_SCALARS) {
14822                 NDR_CHECK(ndr_pull_align(ndr, 4));
14823                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->left));
14824                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->top));
14825                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->right));
14826                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->bottom));
14827         }
14828         if (ndr_flags & NDR_BUFFERS) {
14829         }
14830         return NDR_ERR_SUCCESS;
14831 }
14832
14833 _PUBLIC_ void ndr_print_spoolss_FormArea(struct ndr_print *ndr, const char *name, const struct spoolss_FormArea *r)
14834 {
14835         ndr_print_struct(ndr, name, "spoolss_FormArea");
14836         ndr->depth++;
14837         ndr_print_uint32(ndr, "left", r->left);
14838         ndr_print_uint32(ndr, "top", r->top);
14839         ndr_print_uint32(ndr, "right", r->right);
14840         ndr_print_uint32(ndr, "bottom", r->bottom);
14841         ndr->depth--;
14842 }
14843
14844 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo1 *r)
14845 {
14846         if (ndr_flags & NDR_SCALARS) {
14847                 NDR_CHECK(ndr_push_align(ndr, 4));
14848                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14849                 {
14850                         uint32_t _flags_save_string = ndr->flags;
14851                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14852                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14853                         ndr->flags = _flags_save_string;
14854                 }
14855                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14856                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14857         }
14858         if (ndr_flags & NDR_BUFFERS) {
14859                 {
14860                         uint32_t _flags_save_string = ndr->flags;
14861                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14862                         if (r->form_name) {
14863                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
14864                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
14865                         }
14866                         ndr->flags = _flags_save_string;
14867                 }
14868         }
14869         return NDR_ERR_SUCCESS;
14870 }
14871
14872 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo1 *r)
14873 {
14874         uint32_t _ptr_form_name;
14875         TALLOC_CTX *_mem_save_form_name_0;
14876         if (ndr_flags & NDR_SCALARS) {
14877                 NDR_CHECK(ndr_pull_align(ndr, 4));
14878                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
14879                 {
14880                         uint32_t _flags_save_string = ndr->flags;
14881                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14882                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
14883                         if (_ptr_form_name) {
14884                                 NDR_PULL_ALLOC(ndr, r->form_name);
14885                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
14886                         } else {
14887                                 r->form_name = NULL;
14888                         }
14889                         ndr->flags = _flags_save_string;
14890                 }
14891                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14892                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14893         }
14894         if (ndr_flags & NDR_BUFFERS) {
14895                 {
14896                         uint32_t _flags_save_string = ndr->flags;
14897                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14898                         if (r->form_name) {
14899                                 uint32_t _relative_save_offset;
14900                                 _relative_save_offset = ndr->offset;
14901                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
14902                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
14903                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
14904                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
14905                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
14906                                 ndr->offset = _relative_save_offset;
14907                         }
14908                         ndr->flags = _flags_save_string;
14909                 }
14910         }
14911         return NDR_ERR_SUCCESS;
14912 }
14913
14914 _PUBLIC_ void ndr_print_spoolss_FormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo1 *r)
14915 {
14916         ndr_print_struct(ndr, name, "spoolss_FormInfo1");
14917         ndr->depth++;
14918         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
14919         ndr_print_ptr(ndr, "form_name", r->form_name);
14920         ndr->depth++;
14921         if (r->form_name) {
14922                 ndr_print_string(ndr, "form_name", r->form_name);
14923         }
14924         ndr->depth--;
14925         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
14926         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
14927         ndr->depth--;
14928 }
14929
14930 _PUBLIC_ size_t ndr_size_spoolss_FormInfo1(const struct spoolss_FormInfo1 *r, struct smb_iconv_convenience *ic, int flags)
14931 {
14932         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo1, ic);
14933 }
14934
14935 static enum ndr_err_code ndr_push_spoolss_FormStringType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
14936 {
14937         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
14938         return NDR_ERR_SUCCESS;
14939 }
14940
14941 static enum ndr_err_code ndr_pull_spoolss_FormStringType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
14942 {
14943         uint32_t v;
14944         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
14945         *r = v;
14946         return NDR_ERR_SUCCESS;
14947 }
14948
14949 _PUBLIC_ void ndr_print_spoolss_FormStringType(struct ndr_print *ndr, const char *name, uint32_t r)
14950 {
14951         ndr_print_uint32(ndr, name, r);
14952         ndr->depth++;
14953         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_NONE", SPOOLSS_FORM_STRING_TYPE_NONE, r);
14954         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_MUI_DLL", SPOOLSS_FORM_STRING_TYPE_MUI_DLL, r);
14955         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_FORM_STRING_TYPE_LANG_PAIR", SPOOLSS_FORM_STRING_TYPE_LANG_PAIR, r);
14956         ndr->depth--;
14957 }
14958
14959 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_FormInfo2 *r)
14960 {
14961         if (ndr_flags & NDR_SCALARS) {
14962                 NDR_CHECK(ndr_push_align(ndr, 4));
14963                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
14964                 {
14965                         uint32_t _flags_save_string = ndr->flags;
14966                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14967                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->form_name));
14968                         ndr->flags = _flags_save_string;
14969                 }
14970                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
14971                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
14972                 {
14973                         uint32_t _flags_save_string = ndr->flags;
14974                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
14975                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->keyword));
14976                         ndr->flags = _flags_save_string;
14977                 }
14978                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
14979                 {
14980                         uint32_t _flags_save_string = ndr->flags;
14981                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14982                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->mui_dll));
14983                         ndr->flags = _flags_save_string;
14984                 }
14985                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
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->display_name));
14990                         ndr->flags = _flags_save_string;
14991                 }
14992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
14993         }
14994         if (ndr_flags & NDR_BUFFERS) {
14995                 {
14996                         uint32_t _flags_save_string = ndr->flags;
14997                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
14998                         if (r->form_name) {
14999                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->form_name));
15000                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->form_name));
15001                         }
15002                         ndr->flags = _flags_save_string;
15003                 }
15004                 {
15005                         uint32_t _flags_save_string = ndr->flags;
15006                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15007                         if (r->keyword) {
15008                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->keyword));
15009                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->keyword));
15010                         }
15011                         ndr->flags = _flags_save_string;
15012                 }
15013                 {
15014                         uint32_t _flags_save_string = ndr->flags;
15015                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15016                         if (r->mui_dll) {
15017                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->mui_dll));
15018                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->mui_dll));
15019                         }
15020                         ndr->flags = _flags_save_string;
15021                 }
15022                 {
15023                         uint32_t _flags_save_string = ndr->flags;
15024                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15025                         if (r->display_name) {
15026                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->display_name));
15027                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->display_name));
15028                         }
15029                         ndr->flags = _flags_save_string;
15030                 }
15031         }
15032         return NDR_ERR_SUCCESS;
15033 }
15034
15035 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_FormInfo2 *r)
15036 {
15037         uint32_t _ptr_form_name;
15038         TALLOC_CTX *_mem_save_form_name_0;
15039         uint32_t _ptr_keyword;
15040         TALLOC_CTX *_mem_save_keyword_0;
15041         uint32_t _ptr_mui_dll;
15042         TALLOC_CTX *_mem_save_mui_dll_0;
15043         uint32_t _ptr_display_name;
15044         TALLOC_CTX *_mem_save_display_name_0;
15045         if (ndr_flags & NDR_SCALARS) {
15046                 NDR_CHECK(ndr_pull_align(ndr, 4));
15047                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15048                 {
15049                         uint32_t _flags_save_string = ndr->flags;
15050                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15051                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15052                         if (_ptr_form_name) {
15053                                 NDR_PULL_ALLOC(ndr, r->form_name);
15054                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->form_name, _ptr_form_name));
15055                         } else {
15056                                 r->form_name = NULL;
15057                         }
15058                         ndr->flags = _flags_save_string;
15059                 }
15060                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15061                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15062                 {
15063                         uint32_t _flags_save_string = ndr->flags;
15064                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15065                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15066                         if (_ptr_keyword) {
15067                                 NDR_PULL_ALLOC(ndr, r->keyword);
15068                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->keyword, _ptr_keyword));
15069                         } else {
15070                                 r->keyword = NULL;
15071                         }
15072                         ndr->flags = _flags_save_string;
15073                 }
15074                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15075                 {
15076                         uint32_t _flags_save_string = ndr->flags;
15077                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15078                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15079                         if (_ptr_mui_dll) {
15080                                 NDR_PULL_ALLOC(ndr, r->mui_dll);
15081                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->mui_dll, _ptr_mui_dll));
15082                         } else {
15083                                 r->mui_dll = NULL;
15084                         }
15085                         ndr->flags = _flags_save_string;
15086                 }
15087                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15088                 {
15089                         uint32_t _flags_save_string = ndr->flags;
15090                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15091                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15092                         if (_ptr_display_name) {
15093                                 NDR_PULL_ALLOC(ndr, r->display_name);
15094                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->display_name, _ptr_display_name));
15095                         } else {
15096                                 r->display_name = NULL;
15097                         }
15098                         ndr->flags = _flags_save_string;
15099                 }
15100                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15101         }
15102         if (ndr_flags & NDR_BUFFERS) {
15103                 {
15104                         uint32_t _flags_save_string = ndr->flags;
15105                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15106                         if (r->form_name) {
15107                                 uint32_t _relative_save_offset;
15108                                 _relative_save_offset = ndr->offset;
15109                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->form_name));
15110                                 _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15111                                 NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15112                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->form_name));
15113                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15114                                 ndr->offset = _relative_save_offset;
15115                         }
15116                         ndr->flags = _flags_save_string;
15117                 }
15118                 {
15119                         uint32_t _flags_save_string = ndr->flags;
15120                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
15121                         if (r->keyword) {
15122                                 uint32_t _relative_save_offset;
15123                                 _relative_save_offset = ndr->offset;
15124                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->keyword));
15125                                 _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15126                                 NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15127                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->keyword));
15128                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15129                                 ndr->offset = _relative_save_offset;
15130                         }
15131                         ndr->flags = _flags_save_string;
15132                 }
15133                 {
15134                         uint32_t _flags_save_string = ndr->flags;
15135                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15136                         if (r->mui_dll) {
15137                                 uint32_t _relative_save_offset;
15138                                 _relative_save_offset = ndr->offset;
15139                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->mui_dll));
15140                                 _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15141                                 NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15142                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->mui_dll));
15143                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15144                                 ndr->offset = _relative_save_offset;
15145                         }
15146                         ndr->flags = _flags_save_string;
15147                 }
15148                 {
15149                         uint32_t _flags_save_string = ndr->flags;
15150                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15151                         if (r->display_name) {
15152                                 uint32_t _relative_save_offset;
15153                                 _relative_save_offset = ndr->offset;
15154                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->display_name));
15155                                 _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15156                                 NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15157                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->display_name));
15158                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15159                                 ndr->offset = _relative_save_offset;
15160                         }
15161                         ndr->flags = _flags_save_string;
15162                 }
15163         }
15164         return NDR_ERR_SUCCESS;
15165 }
15166
15167 _PUBLIC_ void ndr_print_spoolss_FormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_FormInfo2 *r)
15168 {
15169         ndr_print_struct(ndr, name, "spoolss_FormInfo2");
15170         ndr->depth++;
15171         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15172         ndr_print_ptr(ndr, "form_name", r->form_name);
15173         ndr->depth++;
15174         if (r->form_name) {
15175                 ndr_print_string(ndr, "form_name", r->form_name);
15176         }
15177         ndr->depth--;
15178         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15179         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15180         ndr_print_ptr(ndr, "keyword", r->keyword);
15181         ndr->depth++;
15182         if (r->keyword) {
15183                 ndr_print_string(ndr, "keyword", r->keyword);
15184         }
15185         ndr->depth--;
15186         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15187         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15188         ndr->depth++;
15189         if (r->mui_dll) {
15190                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15191         }
15192         ndr->depth--;
15193         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15194         ndr_print_ptr(ndr, "display_name", r->display_name);
15195         ndr->depth++;
15196         if (r->display_name) {
15197                 ndr_print_string(ndr, "display_name", r->display_name);
15198         }
15199         ndr->depth--;
15200         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15201         ndr->depth--;
15202 }
15203
15204 _PUBLIC_ size_t ndr_size_spoolss_FormInfo2(const struct spoolss_FormInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15205 {
15206         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo2, ic);
15207 }
15208
15209 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_FormInfo *r)
15210 {
15211         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
15212         if (ndr_flags & NDR_SCALARS) {
15213                 int level = ndr_push_get_switch_value(ndr, r);
15214                 switch (level) {
15215                         case 1: {
15216                                 NDR_CHECK(ndr_push_align(ndr, 4));
15217                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15218                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15219                         break; }
15220
15221                         case 2: {
15222                                 NDR_CHECK(ndr_push_align(ndr, 4));
15223                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
15224                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15225                         break; }
15226
15227                         default: {
15228                         break; }
15229
15230                 }
15231         }
15232         if (ndr_flags & NDR_BUFFERS) {
15233                 int level = ndr_push_get_switch_value(ndr, r);
15234                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
15235                 switch (level) {
15236                         case 1:
15237                                 NDR_CHECK(ndr_push_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15238                         break;
15239
15240                         case 2:
15241                                 NDR_CHECK(ndr_push_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15242                         break;
15243
15244                         default:
15245                         break;
15246
15247                 }
15248         }
15249         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
15250         return NDR_ERR_SUCCESS;
15251 }
15252
15253 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_FormInfo *r)
15254 {
15255         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
15256         int level;
15257         level = ndr_pull_get_switch_value(ndr, r);
15258         if (ndr_flags & NDR_SCALARS) {
15259                 switch (level) {
15260                         case 1: {
15261                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15262                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15263                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_SCALARS, &r->info1));
15264                         break; }
15265
15266                         case 2: {
15267                                 NDR_CHECK(ndr_pull_align(ndr, 4));
15268                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
15269                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_SCALARS, &r->info2));
15270                         break; }
15271
15272                         default: {
15273                         break; }
15274
15275                 }
15276         }
15277         if (ndr_flags & NDR_BUFFERS) {
15278                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
15279                 switch (level) {
15280                         case 1:
15281                                 NDR_CHECK(ndr_pull_spoolss_FormInfo1(ndr, NDR_BUFFERS, &r->info1));
15282                         break;
15283
15284                         case 2:
15285                                 NDR_CHECK(ndr_pull_spoolss_FormInfo2(ndr, NDR_BUFFERS, &r->info2));
15286                         break;
15287
15288                         default:
15289                         break;
15290
15291                 }
15292         }
15293         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
15294         return NDR_ERR_SUCCESS;
15295 }
15296
15297 _PUBLIC_ void ndr_print_spoolss_FormInfo(struct ndr_print *ndr, const char *name, const union spoolss_FormInfo *r)
15298 {
15299         int level;
15300         level = ndr_print_get_switch_value(ndr, r);
15301         ndr_print_union(ndr, name, level, "spoolss_FormInfo");
15302         switch (level) {
15303                 case 1:
15304                         ndr_print_spoolss_FormInfo1(ndr, "info1", &r->info1);
15305                 break;
15306
15307                 case 2:
15308                         ndr_print_spoolss_FormInfo2(ndr, "info2", &r->info2);
15309                 break;
15310
15311                 default:
15312                 break;
15313
15314         }
15315 }
15316
15317 _PUBLIC_ size_t ndr_size_spoolss_FormInfo(const union spoolss_FormInfo *r, uint32_t level, struct smb_iconv_convenience *ic, int flags)
15318 {
15319         return ndr_size_union(r, flags, level, (ndr_push_flags_fn_t)ndr_push_spoolss_FormInfo, ic);
15320 }
15321
15322 static enum ndr_err_code ndr_push_spoolss_AddFormInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo1 *r)
15323 {
15324         if (ndr_flags & NDR_SCALARS) {
15325                 NDR_CHECK(ndr_push_align(ndr, 4));
15326                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15327                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15328                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15329                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15330         }
15331         if (ndr_flags & NDR_BUFFERS) {
15332                 if (r->form_name) {
15333                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15334                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15335                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15336                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15337                 }
15338         }
15339         return NDR_ERR_SUCCESS;
15340 }
15341
15342 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo1 *r)
15343 {
15344         uint32_t _ptr_form_name;
15345         TALLOC_CTX *_mem_save_form_name_0;
15346         if (ndr_flags & NDR_SCALARS) {
15347                 NDR_CHECK(ndr_pull_align(ndr, 4));
15348                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15349                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15350                 if (_ptr_form_name) {
15351                         NDR_PULL_ALLOC(ndr, r->form_name);
15352                 } else {
15353                         r->form_name = NULL;
15354                 }
15355                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15356                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15357         }
15358         if (ndr_flags & NDR_BUFFERS) {
15359                 if (r->form_name) {
15360                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15361                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15362                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15363                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15364                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15365                                 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));
15366                         }
15367                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15368                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15369                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15370                 }
15371         }
15372         return NDR_ERR_SUCCESS;
15373 }
15374
15375 _PUBLIC_ void ndr_print_spoolss_AddFormInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo1 *r)
15376 {
15377         ndr_print_struct(ndr, name, "spoolss_AddFormInfo1");
15378         ndr->depth++;
15379         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15380         ndr_print_ptr(ndr, "form_name", r->form_name);
15381         ndr->depth++;
15382         if (r->form_name) {
15383                 ndr_print_string(ndr, "form_name", r->form_name);
15384         }
15385         ndr->depth--;
15386         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15387         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15388         ndr->depth--;
15389 }
15390
15391 static enum ndr_err_code ndr_push_spoolss_AddFormInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_AddFormInfo2 *r)
15392 {
15393         if (ndr_flags & NDR_SCALARS) {
15394                 NDR_CHECK(ndr_push_align(ndr, 4));
15395                 NDR_CHECK(ndr_push_spoolss_FormFlags(ndr, NDR_SCALARS, r->flags));
15396                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->form_name));
15397                 NDR_CHECK(ndr_push_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15398                 NDR_CHECK(ndr_push_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->keyword));
15400                 NDR_CHECK(ndr_push_spoolss_FormStringType(ndr, NDR_SCALARS, r->string_type));
15401                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->mui_dll));
15402                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->ressource_id));
15403                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->display_name));
15404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->lang_id));
15405         }
15406         if (ndr_flags & NDR_BUFFERS) {
15407                 if (r->form_name) {
15408                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15410                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->form_name, CH_UTF16)));
15411                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->form_name, ndr_charset_length(r->form_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15412                 }
15413                 if (r->keyword) {
15414                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15415                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15416                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->keyword, CH_DOS)));
15417                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->keyword, ndr_charset_length(r->keyword, CH_DOS), sizeof(uint8_t), CH_DOS));
15418                 }
15419                 if (r->mui_dll) {
15420                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15421                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15422                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->mui_dll, CH_UTF16)));
15423                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->mui_dll, ndr_charset_length(r->mui_dll, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15424                 }
15425                 if (r->display_name) {
15426                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15427                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
15428                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->display_name, CH_UTF16)));
15429                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->display_name, ndr_charset_length(r->display_name, CH_UTF16), sizeof(uint16_t), CH_UTF16));
15430                 }
15431         }
15432         return NDR_ERR_SUCCESS;
15433 }
15434
15435 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_AddFormInfo2 *r)
15436 {
15437         uint32_t _ptr_form_name;
15438         TALLOC_CTX *_mem_save_form_name_0;
15439         uint32_t _ptr_keyword;
15440         TALLOC_CTX *_mem_save_keyword_0;
15441         uint32_t _ptr_mui_dll;
15442         TALLOC_CTX *_mem_save_mui_dll_0;
15443         uint32_t _ptr_display_name;
15444         TALLOC_CTX *_mem_save_display_name_0;
15445         if (ndr_flags & NDR_SCALARS) {
15446                 NDR_CHECK(ndr_pull_align(ndr, 4));
15447                 NDR_CHECK(ndr_pull_spoolss_FormFlags(ndr, NDR_SCALARS, &r->flags));
15448                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_form_name));
15449                 if (_ptr_form_name) {
15450                         NDR_PULL_ALLOC(ndr, r->form_name);
15451                 } else {
15452                         r->form_name = NULL;
15453                 }
15454                 NDR_CHECK(ndr_pull_spoolss_FormSize(ndr, NDR_SCALARS, &r->size));
15455                 NDR_CHECK(ndr_pull_spoolss_FormArea(ndr, NDR_SCALARS, &r->area));
15456                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_keyword));
15457                 if (_ptr_keyword) {
15458                         NDR_PULL_ALLOC(ndr, r->keyword);
15459                 } else {
15460                         r->keyword = NULL;
15461                 }
15462                 NDR_CHECK(ndr_pull_spoolss_FormStringType(ndr, NDR_SCALARS, &r->string_type));
15463                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_mui_dll));
15464                 if (_ptr_mui_dll) {
15465                         NDR_PULL_ALLOC(ndr, r->mui_dll);
15466                 } else {
15467                         r->mui_dll = NULL;
15468                 }
15469                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->ressource_id));
15470                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_display_name));
15471                 if (_ptr_display_name) {
15472                         NDR_PULL_ALLOC(ndr, r->display_name);
15473                 } else {
15474                         r->display_name = NULL;
15475                 }
15476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->lang_id));
15477         }
15478         if (ndr_flags & NDR_BUFFERS) {
15479                 if (r->form_name) {
15480                         _mem_save_form_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15481                         NDR_PULL_SET_MEM_CTX(ndr, r->form_name, 0);
15482                         NDR_CHECK(ndr_pull_array_size(ndr, &r->form_name));
15483                         NDR_CHECK(ndr_pull_array_length(ndr, &r->form_name));
15484                         if (ndr_get_array_length(ndr, &r->form_name) > ndr_get_array_size(ndr, &r->form_name)) {
15485                                 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));
15486                         }
15487                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t)));
15488                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->form_name, ndr_get_array_length(ndr, &r->form_name), sizeof(uint16_t), CH_UTF16));
15489                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_form_name_0, 0);
15490                 }
15491                 if (r->keyword) {
15492                         _mem_save_keyword_0 = NDR_PULL_GET_MEM_CTX(ndr);
15493                         NDR_PULL_SET_MEM_CTX(ndr, r->keyword, 0);
15494                         NDR_CHECK(ndr_pull_array_size(ndr, &r->keyword));
15495                         NDR_CHECK(ndr_pull_array_length(ndr, &r->keyword));
15496                         if (ndr_get_array_length(ndr, &r->keyword) > ndr_get_array_size(ndr, &r->keyword)) {
15497                                 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));
15498                         }
15499                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t)));
15500                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->keyword, ndr_get_array_length(ndr, &r->keyword), sizeof(uint8_t), CH_DOS));
15501                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_keyword_0, 0);
15502                 }
15503                 if (r->mui_dll) {
15504                         _mem_save_mui_dll_0 = NDR_PULL_GET_MEM_CTX(ndr);
15505                         NDR_PULL_SET_MEM_CTX(ndr, r->mui_dll, 0);
15506                         NDR_CHECK(ndr_pull_array_size(ndr, &r->mui_dll));
15507                         NDR_CHECK(ndr_pull_array_length(ndr, &r->mui_dll));
15508                         if (ndr_get_array_length(ndr, &r->mui_dll) > ndr_get_array_size(ndr, &r->mui_dll)) {
15509                                 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));
15510                         }
15511                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t)));
15512                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->mui_dll, ndr_get_array_length(ndr, &r->mui_dll), sizeof(uint16_t), CH_UTF16));
15513                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_mui_dll_0, 0);
15514                 }
15515                 if (r->display_name) {
15516                         _mem_save_display_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15517                         NDR_PULL_SET_MEM_CTX(ndr, r->display_name, 0);
15518                         NDR_CHECK(ndr_pull_array_size(ndr, &r->display_name));
15519                         NDR_CHECK(ndr_pull_array_length(ndr, &r->display_name));
15520                         if (ndr_get_array_length(ndr, &r->display_name) > ndr_get_array_size(ndr, &r->display_name)) {
15521                                 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));
15522                         }
15523                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t)));
15524                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->display_name, ndr_get_array_length(ndr, &r->display_name), sizeof(uint16_t), CH_UTF16));
15525                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_display_name_0, 0);
15526                 }
15527         }
15528         return NDR_ERR_SUCCESS;
15529 }
15530
15531 _PUBLIC_ void ndr_print_spoolss_AddFormInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_AddFormInfo2 *r)
15532 {
15533         ndr_print_struct(ndr, name, "spoolss_AddFormInfo2");
15534         ndr->depth++;
15535         ndr_print_spoolss_FormFlags(ndr, "flags", r->flags);
15536         ndr_print_ptr(ndr, "form_name", r->form_name);
15537         ndr->depth++;
15538         if (r->form_name) {
15539                 ndr_print_string(ndr, "form_name", r->form_name);
15540         }
15541         ndr->depth--;
15542         ndr_print_spoolss_FormSize(ndr, "size", &r->size);
15543         ndr_print_spoolss_FormArea(ndr, "area", &r->area);
15544         ndr_print_ptr(ndr, "keyword", r->keyword);
15545         ndr->depth++;
15546         if (r->keyword) {
15547                 ndr_print_string(ndr, "keyword", r->keyword);
15548         }
15549         ndr->depth--;
15550         ndr_print_spoolss_FormStringType(ndr, "string_type", r->string_type);
15551         ndr_print_ptr(ndr, "mui_dll", r->mui_dll);
15552         ndr->depth++;
15553         if (r->mui_dll) {
15554                 ndr_print_string(ndr, "mui_dll", r->mui_dll);
15555         }
15556         ndr->depth--;
15557         ndr_print_uint32(ndr, "ressource_id", r->ressource_id);
15558         ndr_print_ptr(ndr, "display_name", r->display_name);
15559         ndr->depth++;
15560         if (r->display_name) {
15561                 ndr_print_string(ndr, "display_name", r->display_name);
15562         }
15563         ndr->depth--;
15564         ndr_print_uint32(ndr, "lang_id", r->lang_id);
15565         ndr->depth--;
15566 }
15567
15568 static enum ndr_err_code ndr_push_spoolss_AddFormInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_AddFormInfo *r)
15569 {
15570         if (ndr_flags & NDR_SCALARS) {
15571                 int level = ndr_push_get_switch_value(ndr, r);
15572                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
15573                 switch (level) {
15574                         case 1: {
15575                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info1));
15576                         break; }
15577
15578                         case 2: {
15579                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info2));
15580                         break; }
15581
15582                         default:
15583                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15584                 }
15585         }
15586         if (ndr_flags & NDR_BUFFERS) {
15587                 int level = ndr_push_get_switch_value(ndr, r);
15588                 switch (level) {
15589                         case 1:
15590                                 if (r->info1) {
15591                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15592                                 }
15593                         break;
15594
15595                         case 2:
15596                                 if (r->info2) {
15597                                         NDR_CHECK(ndr_push_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15598                                 }
15599                         break;
15600
15601                         default:
15602                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15603                 }
15604         }
15605         return NDR_ERR_SUCCESS;
15606 }
15607
15608 static enum ndr_err_code ndr_pull_spoolss_AddFormInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_AddFormInfo *r)
15609 {
15610         int level;
15611         uint32_t _level;
15612         TALLOC_CTX *_mem_save_info1_0;
15613         TALLOC_CTX *_mem_save_info2_0;
15614         level = ndr_pull_get_switch_value(ndr, r);
15615         if (ndr_flags & NDR_SCALARS) {
15616                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
15617                 if (_level != level) {
15618                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
15619                 }
15620                 switch (level) {
15621                         case 1: {
15622                                 uint32_t _ptr_info1;
15623                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info1));
15624                                 if (_ptr_info1) {
15625                                         NDR_PULL_ALLOC(ndr, r->info1);
15626                                 } else {
15627                                         r->info1 = NULL;
15628                                 }
15629                         break; }
15630
15631                         case 2: {
15632                                 uint32_t _ptr_info2;
15633                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info2));
15634                                 if (_ptr_info2) {
15635                                         NDR_PULL_ALLOC(ndr, r->info2);
15636                                 } else {
15637                                         r->info2 = NULL;
15638                                 }
15639                         break; }
15640
15641                         default:
15642                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15643                 }
15644         }
15645         if (ndr_flags & NDR_BUFFERS) {
15646                 switch (level) {
15647                         case 1:
15648                                 if (r->info1) {
15649                                         _mem_save_info1_0 = NDR_PULL_GET_MEM_CTX(ndr);
15650                                         NDR_PULL_SET_MEM_CTX(ndr, r->info1, 0);
15651                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo1(ndr, NDR_SCALARS|NDR_BUFFERS, r->info1));
15652                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info1_0, 0);
15653                                 }
15654                         break;
15655
15656                         case 2:
15657                                 if (r->info2) {
15658                                         _mem_save_info2_0 = NDR_PULL_GET_MEM_CTX(ndr);
15659                                         NDR_PULL_SET_MEM_CTX(ndr, r->info2, 0);
15660                                         NDR_CHECK(ndr_pull_spoolss_AddFormInfo2(ndr, NDR_SCALARS|NDR_BUFFERS, r->info2));
15661                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info2_0, 0);
15662                                 }
15663                         break;
15664
15665                         default:
15666                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
15667                 }
15668         }
15669         return NDR_ERR_SUCCESS;
15670 }
15671
15672 _PUBLIC_ void ndr_print_spoolss_AddFormInfo(struct ndr_print *ndr, const char *name, const union spoolss_AddFormInfo *r)
15673 {
15674         int level;
15675         level = ndr_print_get_switch_value(ndr, r);
15676         ndr_print_union(ndr, name, level, "spoolss_AddFormInfo");
15677         switch (level) {
15678                 case 1:
15679                         ndr_print_ptr(ndr, "info1", r->info1);
15680                         ndr->depth++;
15681                         if (r->info1) {
15682                                 ndr_print_spoolss_AddFormInfo1(ndr, "info1", r->info1);
15683                         }
15684                         ndr->depth--;
15685                 break;
15686
15687                 case 2:
15688                         ndr_print_ptr(ndr, "info2", r->info2);
15689                         ndr->depth++;
15690                         if (r->info2) {
15691                                 ndr_print_spoolss_AddFormInfo2(ndr, "info2", r->info2);
15692                         }
15693                         ndr->depth--;
15694                 break;
15695
15696                 default:
15697                         ndr_print_bad_level(ndr, name, level);
15698         }
15699 }
15700
15701 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo1 *r)
15702 {
15703         if (ndr_flags & NDR_SCALARS) {
15704                 NDR_CHECK(ndr_push_align(ndr, 4));
15705                 {
15706                         uint32_t _flags_save_string = ndr->flags;
15707                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15708                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15709                         ndr->flags = _flags_save_string;
15710                 }
15711         }
15712         if (ndr_flags & NDR_BUFFERS) {
15713                 {
15714                         uint32_t _flags_save_string = ndr->flags;
15715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15716                         if (r->port_name) {
15717                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15718                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15719                         }
15720                         ndr->flags = _flags_save_string;
15721                 }
15722         }
15723         return NDR_ERR_SUCCESS;
15724 }
15725
15726 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo1 *r)
15727 {
15728         uint32_t _ptr_port_name;
15729         TALLOC_CTX *_mem_save_port_name_0;
15730         if (ndr_flags & NDR_SCALARS) {
15731                 NDR_CHECK(ndr_pull_align(ndr, 4));
15732                 {
15733                         uint32_t _flags_save_string = ndr->flags;
15734                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15735                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15736                         if (_ptr_port_name) {
15737                                 NDR_PULL_ALLOC(ndr, r->port_name);
15738                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15739                         } else {
15740                                 r->port_name = NULL;
15741                         }
15742                         ndr->flags = _flags_save_string;
15743                 }
15744         }
15745         if (ndr_flags & NDR_BUFFERS) {
15746                 {
15747                         uint32_t _flags_save_string = ndr->flags;
15748                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15749                         if (r->port_name) {
15750                                 uint32_t _relative_save_offset;
15751                                 _relative_save_offset = ndr->offset;
15752                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15753                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15754                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15755                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15756                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15757                                 ndr->offset = _relative_save_offset;
15758                         }
15759                         ndr->flags = _flags_save_string;
15760                 }
15761         }
15762         return NDR_ERR_SUCCESS;
15763 }
15764
15765 _PUBLIC_ void ndr_print_spoolss_PortInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo1 *r)
15766 {
15767         ndr_print_struct(ndr, name, "spoolss_PortInfo1");
15768         ndr->depth++;
15769         ndr_print_ptr(ndr, "port_name", r->port_name);
15770         ndr->depth++;
15771         if (r->port_name) {
15772                 ndr_print_string(ndr, "port_name", r->port_name);
15773         }
15774         ndr->depth--;
15775         ndr->depth--;
15776 }
15777
15778 _PUBLIC_ size_t ndr_size_spoolss_PortInfo1(const struct spoolss_PortInfo1 *r, struct smb_iconv_convenience *ic, int flags)
15779 {
15780         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo1, ic);
15781 }
15782
15783 static enum ndr_err_code ndr_push_spoolss_PortType(struct ndr_push *ndr, int ndr_flags, uint32_t r)
15784 {
15785         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15786         return NDR_ERR_SUCCESS;
15787 }
15788
15789 static enum ndr_err_code ndr_pull_spoolss_PortType(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
15790 {
15791         uint32_t v;
15792         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
15793         *r = v;
15794         return NDR_ERR_SUCCESS;
15795 }
15796
15797 _PUBLIC_ void ndr_print_spoolss_PortType(struct ndr_print *ndr, const char *name, uint32_t r)
15798 {
15799         ndr_print_uint32(ndr, name, r);
15800         ndr->depth++;
15801         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_WRITE", SPOOLSS_PORT_TYPE_WRITE, r);
15802         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_READ", SPOOLSS_PORT_TYPE_READ, r);
15803         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_REDIRECTED", SPOOLSS_PORT_TYPE_REDIRECTED, r);
15804         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SPOOLSS_PORT_TYPE_NET_ATTACHED", SPOOLSS_PORT_TYPE_NET_ATTACHED, r);
15805         ndr->depth--;
15806 }
15807
15808 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo2 *r)
15809 {
15810         if (ndr_flags & NDR_SCALARS) {
15811                 NDR_CHECK(ndr_push_align(ndr, 4));
15812                 {
15813                         uint32_t _flags_save_string = ndr->flags;
15814                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15815                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
15816                         ndr->flags = _flags_save_string;
15817                 }
15818                 {
15819                         uint32_t _flags_save_string = ndr->flags;
15820                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15821                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
15822                         ndr->flags = _flags_save_string;
15823                 }
15824                 {
15825                         uint32_t _flags_save_string = ndr->flags;
15826                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15827                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->description));
15828                         ndr->flags = _flags_save_string;
15829                 }
15830                 NDR_CHECK(ndr_push_spoolss_PortType(ndr, NDR_SCALARS, r->port_type));
15831                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
15832         }
15833         if (ndr_flags & NDR_BUFFERS) {
15834                 {
15835                         uint32_t _flags_save_string = ndr->flags;
15836                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15837                         if (r->port_name) {
15838                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
15839                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
15840                         }
15841                         ndr->flags = _flags_save_string;
15842                 }
15843                 {
15844                         uint32_t _flags_save_string = ndr->flags;
15845                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15846                         if (r->monitor_name) {
15847                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
15848                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
15849                         }
15850                         ndr->flags = _flags_save_string;
15851                 }
15852                 {
15853                         uint32_t _flags_save_string = ndr->flags;
15854                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15855                         if (r->description) {
15856                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->description));
15857                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->description));
15858                         }
15859                         ndr->flags = _flags_save_string;
15860                 }
15861         }
15862         return NDR_ERR_SUCCESS;
15863 }
15864
15865 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo2 *r)
15866 {
15867         uint32_t _ptr_port_name;
15868         TALLOC_CTX *_mem_save_port_name_0;
15869         uint32_t _ptr_monitor_name;
15870         TALLOC_CTX *_mem_save_monitor_name_0;
15871         uint32_t _ptr_description;
15872         TALLOC_CTX *_mem_save_description_0;
15873         if (ndr_flags & NDR_SCALARS) {
15874                 NDR_CHECK(ndr_pull_align(ndr, 4));
15875                 {
15876                         uint32_t _flags_save_string = ndr->flags;
15877                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15878                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
15879                         if (_ptr_port_name) {
15880                                 NDR_PULL_ALLOC(ndr, r->port_name);
15881                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
15882                         } else {
15883                                 r->port_name = NULL;
15884                         }
15885                         ndr->flags = _flags_save_string;
15886                 }
15887                 {
15888                         uint32_t _flags_save_string = ndr->flags;
15889                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15890                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
15891                         if (_ptr_monitor_name) {
15892                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
15893                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
15894                         } else {
15895                                 r->monitor_name = NULL;
15896                         }
15897                         ndr->flags = _flags_save_string;
15898                 }
15899                 {
15900                         uint32_t _flags_save_string = ndr->flags;
15901                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15902                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_description));
15903                         if (_ptr_description) {
15904                                 NDR_PULL_ALLOC(ndr, r->description);
15905                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->description, _ptr_description));
15906                         } else {
15907                                 r->description = NULL;
15908                         }
15909                         ndr->flags = _flags_save_string;
15910                 }
15911                 NDR_CHECK(ndr_pull_spoolss_PortType(ndr, NDR_SCALARS, &r->port_type));
15912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
15913         }
15914         if (ndr_flags & NDR_BUFFERS) {
15915                 {
15916                         uint32_t _flags_save_string = ndr->flags;
15917                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15918                         if (r->port_name) {
15919                                 uint32_t _relative_save_offset;
15920                                 _relative_save_offset = ndr->offset;
15921                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
15922                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15923                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
15924                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
15925                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
15926                                 ndr->offset = _relative_save_offset;
15927                         }
15928                         ndr->flags = _flags_save_string;
15929                 }
15930                 {
15931                         uint32_t _flags_save_string = ndr->flags;
15932                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15933                         if (r->monitor_name) {
15934                                 uint32_t _relative_save_offset;
15935                                 _relative_save_offset = ndr->offset;
15936                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
15937                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
15938                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
15939                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
15940                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
15941                                 ndr->offset = _relative_save_offset;
15942                         }
15943                         ndr->flags = _flags_save_string;
15944                 }
15945                 {
15946                         uint32_t _flags_save_string = ndr->flags;
15947                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
15948                         if (r->description) {
15949                                 uint32_t _relative_save_offset;
15950                                 _relative_save_offset = ndr->offset;
15951                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->description));
15952                                 _mem_save_description_0 = NDR_PULL_GET_MEM_CTX(ndr);
15953                                 NDR_PULL_SET_MEM_CTX(ndr, r->description, 0);
15954                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->description));
15955                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_description_0, 0);
15956                                 ndr->offset = _relative_save_offset;
15957                         }
15958                         ndr->flags = _flags_save_string;
15959                 }
15960         }
15961         return NDR_ERR_SUCCESS;
15962 }
15963
15964 _PUBLIC_ void ndr_print_spoolss_PortInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo2 *r)
15965 {
15966         ndr_print_struct(ndr, name, "spoolss_PortInfo2");
15967         ndr->depth++;
15968         ndr_print_ptr(ndr, "port_name", r->port_name);
15969         ndr->depth++;
15970         if (r->port_name) {
15971                 ndr_print_string(ndr, "port_name", r->port_name);
15972         }
15973         ndr->depth--;
15974         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
15975         ndr->depth++;
15976         if (r->monitor_name) {
15977                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
15978         }
15979         ndr->depth--;
15980         ndr_print_ptr(ndr, "description", r->description);
15981         ndr->depth++;
15982         if (r->description) {
15983                 ndr_print_string(ndr, "description", r->description);
15984         }
15985         ndr->depth--;
15986         ndr_print_spoolss_PortType(ndr, "port_type", r->port_type);
15987         ndr_print_uint32(ndr, "reserved", r->reserved);
15988         ndr->depth--;
15989 }
15990
15991 _PUBLIC_ size_t ndr_size_spoolss_PortInfo2(const struct spoolss_PortInfo2 *r, struct smb_iconv_convenience *ic, int flags)
15992 {
15993         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo2, ic);
15994 }
15995
15996 static enum ndr_err_code ndr_push_spoolss_PortStatus(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortStatus r)
15997 {
15998         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
15999         return NDR_ERR_SUCCESS;
16000 }
16001
16002 static enum ndr_err_code ndr_pull_spoolss_PortStatus(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortStatus *r)
16003 {
16004         uint32_t v;
16005         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16006         *r = v;
16007         return NDR_ERR_SUCCESS;
16008 }
16009
16010 _PUBLIC_ void ndr_print_spoolss_PortStatus(struct ndr_print *ndr, const char *name, enum spoolss_PortStatus r)
16011 {
16012         const char *val = NULL;
16013
16014         switch (r) {
16015                 case PORT_STATUS_CLEAR: val = "PORT_STATUS_CLEAR"; break;
16016                 case PORT_STATUS_OFFLINE: val = "PORT_STATUS_OFFLINE"; break;
16017                 case PORT_STATUS_PAPER_JAM: val = "PORT_STATUS_PAPER_JAM"; break;
16018                 case PORT_STATUS_PAPER_OUT: val = "PORT_STATUS_PAPER_OUT"; break;
16019                 case PORT_STATUS_OUTPUT_BIN_FULL: val = "PORT_STATUS_OUTPUT_BIN_FULL"; break;
16020                 case PORT_STATUS_PAPER_PROBLEM: val = "PORT_STATUS_PAPER_PROBLEM"; break;
16021                 case PORT_STATUS_NO_TONER: val = "PORT_STATUS_NO_TONER"; break;
16022                 case PORT_STATUS_DOOR_OPEN: val = "PORT_STATUS_DOOR_OPEN"; break;
16023                 case PORT_STATUS_USER_INTERVENTION: val = "PORT_STATUS_USER_INTERVENTION"; break;
16024                 case PORT_STATUS_OUT_OF_MEMORY: val = "PORT_STATUS_OUT_OF_MEMORY"; break;
16025                 case PORT_STATUS_TONER_LOW: val = "PORT_STATUS_TONER_LOW"; break;
16026                 case PORT_STATUS_WARMING_UP: val = "PORT_STATUS_WARMING_UP"; break;
16027                 case PORT_STATUS_POWER_SAVE: val = "PORT_STATUS_POWER_SAVE"; break;
16028         }
16029         ndr_print_enum(ndr, name, "ENUM", val, r);
16030 }
16031
16032 static enum ndr_err_code ndr_push_spoolss_PortSeverity(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortSeverity r)
16033 {
16034         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16035         return NDR_ERR_SUCCESS;
16036 }
16037
16038 static enum ndr_err_code ndr_pull_spoolss_PortSeverity(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortSeverity *r)
16039 {
16040         uint32_t v;
16041         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16042         *r = v;
16043         return NDR_ERR_SUCCESS;
16044 }
16045
16046 _PUBLIC_ void ndr_print_spoolss_PortSeverity(struct ndr_print *ndr, const char *name, enum spoolss_PortSeverity r)
16047 {
16048         const char *val = NULL;
16049
16050         switch (r) {
16051                 case PORT_STATUS_TYPE_ERROR: val = "PORT_STATUS_TYPE_ERROR"; break;
16052                 case PORT_STATUS_TYPE_WARNING: val = "PORT_STATUS_TYPE_WARNING"; break;
16053                 case PORT_STATUS_TYPE_INFO: val = "PORT_STATUS_TYPE_INFO"; break;
16054         }
16055         ndr_print_enum(ndr, name, "ENUM", val, r);
16056 }
16057
16058 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfo3 *r)
16059 {
16060         if (ndr_flags & NDR_SCALARS) {
16061                 NDR_CHECK(ndr_push_align(ndr, 4));
16062                 NDR_CHECK(ndr_push_spoolss_PortStatus(ndr, NDR_SCALARS, r->status));
16063                 {
16064                         uint32_t _flags_save_string = ndr->flags;
16065                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16066                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->status_string));
16067                         ndr->flags = _flags_save_string;
16068                 }
16069                 NDR_CHECK(ndr_push_spoolss_PortSeverity(ndr, NDR_SCALARS, r->severity));
16070         }
16071         if (ndr_flags & NDR_BUFFERS) {
16072                 {
16073                         uint32_t _flags_save_string = ndr->flags;
16074                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16075                         if (r->status_string) {
16076                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->status_string));
16077                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->status_string));
16078                         }
16079                         ndr->flags = _flags_save_string;
16080                 }
16081         }
16082         return NDR_ERR_SUCCESS;
16083 }
16084
16085 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfo3 *r)
16086 {
16087         uint32_t _ptr_status_string;
16088         TALLOC_CTX *_mem_save_status_string_0;
16089         if (ndr_flags & NDR_SCALARS) {
16090                 NDR_CHECK(ndr_pull_align(ndr, 4));
16091                 NDR_CHECK(ndr_pull_spoolss_PortStatus(ndr, NDR_SCALARS, &r->status));
16092                 {
16093                         uint32_t _flags_save_string = ndr->flags;
16094                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16095                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_status_string));
16096                         if (_ptr_status_string) {
16097                                 NDR_PULL_ALLOC(ndr, r->status_string);
16098                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->status_string, _ptr_status_string));
16099                         } else {
16100                                 r->status_string = NULL;
16101                         }
16102                         ndr->flags = _flags_save_string;
16103                 }
16104                 NDR_CHECK(ndr_pull_spoolss_PortSeverity(ndr, NDR_SCALARS, &r->severity));
16105         }
16106         if (ndr_flags & NDR_BUFFERS) {
16107                 {
16108                         uint32_t _flags_save_string = ndr->flags;
16109                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16110                         if (r->status_string) {
16111                                 uint32_t _relative_save_offset;
16112                                 _relative_save_offset = ndr->offset;
16113                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->status_string));
16114                                 _mem_save_status_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
16115                                 NDR_PULL_SET_MEM_CTX(ndr, r->status_string, 0);
16116                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->status_string));
16117                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_string_0, 0);
16118                                 ndr->offset = _relative_save_offset;
16119                         }
16120                         ndr->flags = _flags_save_string;
16121                 }
16122         }
16123         return NDR_ERR_SUCCESS;
16124 }
16125
16126 _PUBLIC_ void ndr_print_spoolss_PortInfo3(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfo3 *r)
16127 {
16128         ndr_print_struct(ndr, name, "spoolss_PortInfo3");
16129         ndr->depth++;
16130         ndr_print_spoolss_PortStatus(ndr, "status", r->status);
16131         ndr_print_ptr(ndr, "status_string", r->status_string);
16132         ndr->depth++;
16133         if (r->status_string) {
16134                 ndr_print_string(ndr, "status_string", r->status_string);
16135         }
16136         ndr->depth--;
16137         ndr_print_spoolss_PortSeverity(ndr, "severity", r->severity);
16138         ndr->depth--;
16139 }
16140
16141 _PUBLIC_ size_t ndr_size_spoolss_PortInfo3(const struct spoolss_PortInfo3 *r, struct smb_iconv_convenience *ic, int flags)
16142 {
16143         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfo3, ic);
16144 }
16145
16146 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfoFF(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortInfoFF *r)
16147 {
16148         if (ndr_flags & NDR_SCALARS) {
16149                 NDR_CHECK(ndr_push_align(ndr, 4));
16150                 {
16151                         uint32_t _flags_save_string = ndr->flags;
16152                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16153                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->port_name));
16154                         ndr->flags = _flags_save_string;
16155                 }
16156                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->monitor_data));
16157         }
16158         if (ndr_flags & NDR_BUFFERS) {
16159                 {
16160                         uint32_t _flags_save_string = ndr->flags;
16161                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16162                         if (r->port_name) {
16163                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->port_name));
16164                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->port_name));
16165                         }
16166                         ndr->flags = _flags_save_string;
16167                 }
16168         }
16169         return NDR_ERR_SUCCESS;
16170 }
16171
16172 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfoFF(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortInfoFF *r)
16173 {
16174         uint32_t _ptr_port_name;
16175         TALLOC_CTX *_mem_save_port_name_0;
16176         if (ndr_flags & NDR_SCALARS) {
16177                 NDR_CHECK(ndr_pull_align(ndr, 4));
16178                 {
16179                         uint32_t _flags_save_string = ndr->flags;
16180                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16181                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_port_name));
16182                         if (_ptr_port_name) {
16183                                 NDR_PULL_ALLOC(ndr, r->port_name);
16184                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->port_name, _ptr_port_name));
16185                         } else {
16186                                 r->port_name = NULL;
16187                         }
16188                         ndr->flags = _flags_save_string;
16189                 }
16190                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->monitor_data));
16191         }
16192         if (ndr_flags & NDR_BUFFERS) {
16193                 {
16194                         uint32_t _flags_save_string = ndr->flags;
16195                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16196                         if (r->port_name) {
16197                                 uint32_t _relative_save_offset;
16198                                 _relative_save_offset = ndr->offset;
16199                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->port_name));
16200                                 _mem_save_port_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16201                                 NDR_PULL_SET_MEM_CTX(ndr, r->port_name, 0);
16202                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->port_name));
16203                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_port_name_0, 0);
16204                                 ndr->offset = _relative_save_offset;
16205                         }
16206                         ndr->flags = _flags_save_string;
16207                 }
16208         }
16209         return NDR_ERR_SUCCESS;
16210 }
16211
16212 _PUBLIC_ void ndr_print_spoolss_PortInfoFF(struct ndr_print *ndr, const char *name, const struct spoolss_PortInfoFF *r)
16213 {
16214         ndr_print_struct(ndr, name, "spoolss_PortInfoFF");
16215         ndr->depth++;
16216         ndr_print_ptr(ndr, "port_name", r->port_name);
16217         ndr->depth++;
16218         if (r->port_name) {
16219                 ndr_print_string(ndr, "port_name", r->port_name);
16220         }
16221         ndr->depth--;
16222         ndr_print_DATA_BLOB(ndr, "monitor_data", r->monitor_data);
16223         ndr->depth--;
16224 }
16225
16226 _PUBLIC_ size_t ndr_size_spoolss_PortInfoFF(const struct spoolss_PortInfoFF *r, struct smb_iconv_convenience *ic, int flags)
16227 {
16228         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PortInfoFF, ic);
16229 }
16230
16231 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PortInfo *r)
16232 {
16233         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16234         if (ndr_flags & NDR_SCALARS) {
16235                 int level = ndr_push_get_switch_value(ndr, r);
16236                 switch (level) {
16237                         case 1: {
16238                                 NDR_CHECK(ndr_push_align(ndr, 4));
16239                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16240                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16241                         break; }
16242
16243                         case 2: {
16244                                 NDR_CHECK(ndr_push_align(ndr, 4));
16245                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16246                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16247                         break; }
16248
16249                         case 3: {
16250                                 NDR_CHECK(ndr_push_align(ndr, 4));
16251                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16252                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16253                         break; }
16254
16255                         case 0xff: {
16256                                 NDR_CHECK(ndr_push_align(ndr, 4));
16257                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16258                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16259                         break; }
16260
16261                         default: {
16262                         break; }
16263
16264                 }
16265         }
16266         if (ndr_flags & NDR_BUFFERS) {
16267                 int level = ndr_push_get_switch_value(ndr, r);
16268                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16269                 switch (level) {
16270                         case 1:
16271                                 NDR_CHECK(ndr_push_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16272                         break;
16273
16274                         case 2:
16275                                 NDR_CHECK(ndr_push_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16276                         break;
16277
16278                         case 3:
16279                                 NDR_CHECK(ndr_push_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16280                         break;
16281
16282                         case 0xff:
16283                                 NDR_CHECK(ndr_push_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16284                         break;
16285
16286                         default:
16287                         break;
16288
16289                 }
16290         }
16291         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16292         return NDR_ERR_SUCCESS;
16293 }
16294
16295 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PortInfo *r)
16296 {
16297         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16298         int level;
16299         level = ndr_pull_get_switch_value(ndr, r);
16300         if (ndr_flags & NDR_SCALARS) {
16301                 switch (level) {
16302                         case 1: {
16303                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16304                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16305                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_SCALARS, &r->info1));
16306                         break; }
16307
16308                         case 2: {
16309                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16310                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16311                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_SCALARS, &r->info2));
16312                         break; }
16313
16314                         case 3: {
16315                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16316                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16317                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_SCALARS, &r->info3));
16318                         break; }
16319
16320                         case 0xff: {
16321                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16322                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16323                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_SCALARS, &r->infoFF));
16324                         break; }
16325
16326                         default: {
16327                         break; }
16328
16329                 }
16330         }
16331         if (ndr_flags & NDR_BUFFERS) {
16332                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16333                 switch (level) {
16334                         case 1:
16335                                 NDR_CHECK(ndr_pull_spoolss_PortInfo1(ndr, NDR_BUFFERS, &r->info1));
16336                         break;
16337
16338                         case 2:
16339                                 NDR_CHECK(ndr_pull_spoolss_PortInfo2(ndr, NDR_BUFFERS, &r->info2));
16340                         break;
16341
16342                         case 3:
16343                                 NDR_CHECK(ndr_pull_spoolss_PortInfo3(ndr, NDR_BUFFERS, &r->info3));
16344                         break;
16345
16346                         case 0xff:
16347                                 NDR_CHECK(ndr_pull_spoolss_PortInfoFF(ndr, NDR_BUFFERS, &r->infoFF));
16348                         break;
16349
16350                         default:
16351                         break;
16352
16353                 }
16354         }
16355         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16356         return NDR_ERR_SUCCESS;
16357 }
16358
16359 _PUBLIC_ void ndr_print_spoolss_PortInfo(struct ndr_print *ndr, const char *name, const union spoolss_PortInfo *r)
16360 {
16361         int level;
16362         level = ndr_print_get_switch_value(ndr, r);
16363         ndr_print_union(ndr, name, level, "spoolss_PortInfo");
16364         switch (level) {
16365                 case 1:
16366                         ndr_print_spoolss_PortInfo1(ndr, "info1", &r->info1);
16367                 break;
16368
16369                 case 2:
16370                         ndr_print_spoolss_PortInfo2(ndr, "info2", &r->info2);
16371                 break;
16372
16373                 case 3:
16374                         ndr_print_spoolss_PortInfo3(ndr, "info3", &r->info3);
16375                 break;
16376
16377                 case 0xff:
16378                         ndr_print_spoolss_PortInfoFF(ndr, "infoFF", &r->infoFF);
16379                 break;
16380
16381                 default:
16382                 break;
16383
16384         }
16385 }
16386
16387 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo1 *r)
16388 {
16389         if (ndr_flags & NDR_SCALARS) {
16390                 NDR_CHECK(ndr_push_align(ndr, 4));
16391                 {
16392                         uint32_t _flags_save_string = ndr->flags;
16393                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16394                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16395                         ndr->flags = _flags_save_string;
16396                 }
16397         }
16398         if (ndr_flags & NDR_BUFFERS) {
16399                 {
16400                         uint32_t _flags_save_string = ndr->flags;
16401                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16402                         if (r->monitor_name) {
16403                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16404                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16405                         }
16406                         ndr->flags = _flags_save_string;
16407                 }
16408         }
16409         return NDR_ERR_SUCCESS;
16410 }
16411
16412 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo1 *r)
16413 {
16414         uint32_t _ptr_monitor_name;
16415         TALLOC_CTX *_mem_save_monitor_name_0;
16416         if (ndr_flags & NDR_SCALARS) {
16417                 NDR_CHECK(ndr_pull_align(ndr, 4));
16418                 {
16419                         uint32_t _flags_save_string = ndr->flags;
16420                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16421                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16422                         if (_ptr_monitor_name) {
16423                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16424                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16425                         } else {
16426                                 r->monitor_name = NULL;
16427                         }
16428                         ndr->flags = _flags_save_string;
16429                 }
16430         }
16431         if (ndr_flags & NDR_BUFFERS) {
16432                 {
16433                         uint32_t _flags_save_string = ndr->flags;
16434                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16435                         if (r->monitor_name) {
16436                                 uint32_t _relative_save_offset;
16437                                 _relative_save_offset = ndr->offset;
16438                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16439                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16440                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16441                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16442                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16443                                 ndr->offset = _relative_save_offset;
16444                         }
16445                         ndr->flags = _flags_save_string;
16446                 }
16447         }
16448         return NDR_ERR_SUCCESS;
16449 }
16450
16451 _PUBLIC_ void ndr_print_spoolss_MonitorInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo1 *r)
16452 {
16453         ndr_print_struct(ndr, name, "spoolss_MonitorInfo1");
16454         ndr->depth++;
16455         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16456         ndr->depth++;
16457         if (r->monitor_name) {
16458                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16459         }
16460         ndr->depth--;
16461         ndr->depth--;
16462 }
16463
16464 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo1(const struct spoolss_MonitorInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16465 {
16466         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo1, ic);
16467 }
16468
16469 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorInfo2 *r)
16470 {
16471         if (ndr_flags & NDR_SCALARS) {
16472                 NDR_CHECK(ndr_push_align(ndr, 4));
16473                 {
16474                         uint32_t _flags_save_string = ndr->flags;
16475                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16476                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->monitor_name));
16477                         ndr->flags = _flags_save_string;
16478                 }
16479                 {
16480                         uint32_t _flags_save_string = ndr->flags;
16481                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16482                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->environment));
16483                         ndr->flags = _flags_save_string;
16484                 }
16485                 {
16486                         uint32_t _flags_save_string = ndr->flags;
16487                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16488                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->dll_name));
16489                         ndr->flags = _flags_save_string;
16490                 }
16491         }
16492         if (ndr_flags & NDR_BUFFERS) {
16493                 {
16494                         uint32_t _flags_save_string = ndr->flags;
16495                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16496                         if (r->monitor_name) {
16497                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->monitor_name));
16498                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->monitor_name));
16499                         }
16500                         ndr->flags = _flags_save_string;
16501                 }
16502                 {
16503                         uint32_t _flags_save_string = ndr->flags;
16504                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16505                         if (r->environment) {
16506                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->environment));
16507                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->environment));
16508                         }
16509                         ndr->flags = _flags_save_string;
16510                 }
16511                 {
16512                         uint32_t _flags_save_string = ndr->flags;
16513                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16514                         if (r->dll_name) {
16515                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->dll_name));
16516                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
16517                         }
16518                         ndr->flags = _flags_save_string;
16519                 }
16520         }
16521         return NDR_ERR_SUCCESS;
16522 }
16523
16524 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorInfo2 *r)
16525 {
16526         uint32_t _ptr_monitor_name;
16527         TALLOC_CTX *_mem_save_monitor_name_0;
16528         uint32_t _ptr_environment;
16529         TALLOC_CTX *_mem_save_environment_0;
16530         uint32_t _ptr_dll_name;
16531         TALLOC_CTX *_mem_save_dll_name_0;
16532         if (ndr_flags & NDR_SCALARS) {
16533                 NDR_CHECK(ndr_pull_align(ndr, 4));
16534                 {
16535                         uint32_t _flags_save_string = ndr->flags;
16536                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16537                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_monitor_name));
16538                         if (_ptr_monitor_name) {
16539                                 NDR_PULL_ALLOC(ndr, r->monitor_name);
16540                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->monitor_name, _ptr_monitor_name));
16541                         } else {
16542                                 r->monitor_name = NULL;
16543                         }
16544                         ndr->flags = _flags_save_string;
16545                 }
16546                 {
16547                         uint32_t _flags_save_string = ndr->flags;
16548                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16549                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
16550                         if (_ptr_environment) {
16551                                 NDR_PULL_ALLOC(ndr, r->environment);
16552                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->environment, _ptr_environment));
16553                         } else {
16554                                 r->environment = NULL;
16555                         }
16556                         ndr->flags = _flags_save_string;
16557                 }
16558                 {
16559                         uint32_t _flags_save_string = ndr->flags;
16560                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16561                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_dll_name));
16562                         if (_ptr_dll_name) {
16563                                 NDR_PULL_ALLOC(ndr, r->dll_name);
16564                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->dll_name, _ptr_dll_name));
16565                         } else {
16566                                 r->dll_name = NULL;
16567                         }
16568                         ndr->flags = _flags_save_string;
16569                 }
16570         }
16571         if (ndr_flags & NDR_BUFFERS) {
16572                 {
16573                         uint32_t _flags_save_string = ndr->flags;
16574                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16575                         if (r->monitor_name) {
16576                                 uint32_t _relative_save_offset;
16577                                 _relative_save_offset = ndr->offset;
16578                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->monitor_name));
16579                                 _mem_save_monitor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16580                                 NDR_PULL_SET_MEM_CTX(ndr, r->monitor_name, 0);
16581                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->monitor_name));
16582                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_monitor_name_0, 0);
16583                                 ndr->offset = _relative_save_offset;
16584                         }
16585                         ndr->flags = _flags_save_string;
16586                 }
16587                 {
16588                         uint32_t _flags_save_string = ndr->flags;
16589                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16590                         if (r->environment) {
16591                                 uint32_t _relative_save_offset;
16592                                 _relative_save_offset = ndr->offset;
16593                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->environment));
16594                                 _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
16595                                 NDR_PULL_SET_MEM_CTX(ndr, r->environment, 0);
16596                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->environment));
16597                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
16598                                 ndr->offset = _relative_save_offset;
16599                         }
16600                         ndr->flags = _flags_save_string;
16601                 }
16602                 {
16603                         uint32_t _flags_save_string = ndr->flags;
16604                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16605                         if (r->dll_name) {
16606                                 uint32_t _relative_save_offset;
16607                                 _relative_save_offset = ndr->offset;
16608                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->dll_name));
16609                                 _mem_save_dll_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
16610                                 NDR_PULL_SET_MEM_CTX(ndr, r->dll_name, 0);
16611                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
16612                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_dll_name_0, 0);
16613                                 ndr->offset = _relative_save_offset;
16614                         }
16615                         ndr->flags = _flags_save_string;
16616                 }
16617         }
16618         return NDR_ERR_SUCCESS;
16619 }
16620
16621 _PUBLIC_ void ndr_print_spoolss_MonitorInfo2(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorInfo2 *r)
16622 {
16623         ndr_print_struct(ndr, name, "spoolss_MonitorInfo2");
16624         ndr->depth++;
16625         ndr_print_ptr(ndr, "monitor_name", r->monitor_name);
16626         ndr->depth++;
16627         if (r->monitor_name) {
16628                 ndr_print_string(ndr, "monitor_name", r->monitor_name);
16629         }
16630         ndr->depth--;
16631         ndr_print_ptr(ndr, "environment", r->environment);
16632         ndr->depth++;
16633         if (r->environment) {
16634                 ndr_print_string(ndr, "environment", r->environment);
16635         }
16636         ndr->depth--;
16637         ndr_print_ptr(ndr, "dll_name", r->dll_name);
16638         ndr->depth++;
16639         if (r->dll_name) {
16640                 ndr_print_string(ndr, "dll_name", r->dll_name);
16641         }
16642         ndr->depth--;
16643         ndr->depth--;
16644 }
16645
16646 _PUBLIC_ size_t ndr_size_spoolss_MonitorInfo2(const struct spoolss_MonitorInfo2 *r, struct smb_iconv_convenience *ic, int flags)
16647 {
16648         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_MonitorInfo2, ic);
16649 }
16650
16651 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_MonitorInfo *r)
16652 {
16653         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16654         if (ndr_flags & NDR_SCALARS) {
16655                 int level = ndr_push_get_switch_value(ndr, r);
16656                 switch (level) {
16657                         case 1: {
16658                                 NDR_CHECK(ndr_push_align(ndr, 4));
16659                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16660                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16661                         break; }
16662
16663                         case 2: {
16664                                 NDR_CHECK(ndr_push_align(ndr, 4));
16665                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16666                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16667                         break; }
16668
16669                         default: {
16670                         break; }
16671
16672                 }
16673         }
16674         if (ndr_flags & NDR_BUFFERS) {
16675                 int level = ndr_push_get_switch_value(ndr, r);
16676                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16677                 switch (level) {
16678                         case 1:
16679                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16680                         break;
16681
16682                         case 2:
16683                                 NDR_CHECK(ndr_push_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16684                         break;
16685
16686                         default:
16687                         break;
16688
16689                 }
16690         }
16691         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16692         return NDR_ERR_SUCCESS;
16693 }
16694
16695 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_MonitorInfo *r)
16696 {
16697         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16698         int level;
16699         level = ndr_pull_get_switch_value(ndr, r);
16700         if (ndr_flags & NDR_SCALARS) {
16701                 switch (level) {
16702                         case 1: {
16703                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16704                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16705                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_SCALARS, &r->info1));
16706                         break; }
16707
16708                         case 2: {
16709                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16710                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16711                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_SCALARS, &r->info2));
16712                         break; }
16713
16714                         default: {
16715                         break; }
16716
16717                 }
16718         }
16719         if (ndr_flags & NDR_BUFFERS) {
16720                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16721                 switch (level) {
16722                         case 1:
16723                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo1(ndr, NDR_BUFFERS, &r->info1));
16724                         break;
16725
16726                         case 2:
16727                                 NDR_CHECK(ndr_pull_spoolss_MonitorInfo2(ndr, NDR_BUFFERS, &r->info2));
16728                         break;
16729
16730                         default:
16731                         break;
16732
16733                 }
16734         }
16735         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16736         return NDR_ERR_SUCCESS;
16737 }
16738
16739 _PUBLIC_ void ndr_print_spoolss_MonitorInfo(struct ndr_print *ndr, const char *name, const union spoolss_MonitorInfo *r)
16740 {
16741         int level;
16742         level = ndr_print_get_switch_value(ndr, r);
16743         ndr_print_union(ndr, name, level, "spoolss_MonitorInfo");
16744         switch (level) {
16745                 case 1:
16746                         ndr_print_spoolss_MonitorInfo1(ndr, "info1", &r->info1);
16747                 break;
16748
16749                 case 2:
16750                         ndr_print_spoolss_MonitorInfo2(ndr, "info2", &r->info2);
16751                 break;
16752
16753                 default:
16754                 break;
16755
16756         }
16757 }
16758
16759 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrintProcDataTypesInfo1 *r)
16760 {
16761         if (ndr_flags & NDR_SCALARS) {
16762                 NDR_CHECK(ndr_push_align(ndr, 4));
16763                 {
16764                         uint32_t _flags_save_string = ndr->flags;
16765                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16766                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->name_array));
16767                         ndr->flags = _flags_save_string;
16768                 }
16769         }
16770         if (ndr_flags & NDR_BUFFERS) {
16771                 {
16772                         uint32_t _flags_save_string = ndr->flags;
16773                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16774                         if (r->name_array) {
16775                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->name_array));
16776                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->name_array));
16777                         }
16778                         ndr->flags = _flags_save_string;
16779                 }
16780         }
16781         return NDR_ERR_SUCCESS;
16782 }
16783
16784 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrintProcDataTypesInfo1 *r)
16785 {
16786         uint32_t _ptr_name_array;
16787         TALLOC_CTX *_mem_save_name_array_0;
16788         if (ndr_flags & NDR_SCALARS) {
16789                 NDR_CHECK(ndr_pull_align(ndr, 4));
16790                 {
16791                         uint32_t _flags_save_string = ndr->flags;
16792                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16793                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_name_array));
16794                         if (_ptr_name_array) {
16795                                 NDR_PULL_ALLOC(ndr, r->name_array);
16796                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->name_array, _ptr_name_array));
16797                         } else {
16798                                 r->name_array = NULL;
16799                         }
16800                         ndr->flags = _flags_save_string;
16801                 }
16802         }
16803         if (ndr_flags & NDR_BUFFERS) {
16804                 {
16805                         uint32_t _flags_save_string = ndr->flags;
16806                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
16807                         if (r->name_array) {
16808                                 uint32_t _relative_save_offset;
16809                                 _relative_save_offset = ndr->offset;
16810                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->name_array));
16811                                 _mem_save_name_array_0 = NDR_PULL_GET_MEM_CTX(ndr);
16812                                 NDR_PULL_SET_MEM_CTX(ndr, r->name_array, 0);
16813                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->name_array));
16814                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_name_array_0, 0);
16815                                 ndr->offset = _relative_save_offset;
16816                         }
16817                         ndr->flags = _flags_save_string;
16818                 }
16819         }
16820         return NDR_ERR_SUCCESS;
16821 }
16822
16823 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo1(struct ndr_print *ndr, const char *name, const struct spoolss_PrintProcDataTypesInfo1 *r)
16824 {
16825         ndr_print_struct(ndr, name, "spoolss_PrintProcDataTypesInfo1");
16826         ndr->depth++;
16827         ndr_print_ptr(ndr, "name_array", r->name_array);
16828         ndr->depth++;
16829         if (r->name_array) {
16830                 ndr_print_string(ndr, "name_array", r->name_array);
16831         }
16832         ndr->depth--;
16833         ndr->depth--;
16834 }
16835
16836 _PUBLIC_ size_t ndr_size_spoolss_PrintProcDataTypesInfo1(const struct spoolss_PrintProcDataTypesInfo1 *r, struct smb_iconv_convenience *ic, int flags)
16837 {
16838         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrintProcDataTypesInfo1, ic);
16839 }
16840
16841 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintProcDataTypesInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_PrintProcDataTypesInfo *r)
16842 {
16843         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
16844         if (ndr_flags & NDR_SCALARS) {
16845                 int level = ndr_push_get_switch_value(ndr, r);
16846                 switch (level) {
16847                         case 1: {
16848                                 NDR_CHECK(ndr_push_align(ndr, 4));
16849                                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
16850                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16851                         break; }
16852
16853                         default: {
16854                         break; }
16855
16856                 }
16857         }
16858         if (ndr_flags & NDR_BUFFERS) {
16859                 int level = ndr_push_get_switch_value(ndr, r);
16860                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
16861                 switch (level) {
16862                         case 1:
16863                                 NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16864                         break;
16865
16866                         default:
16867                         break;
16868
16869                 }
16870         }
16871         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
16872         return NDR_ERR_SUCCESS;
16873 }
16874
16875 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintProcDataTypesInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_PrintProcDataTypesInfo *r)
16876 {
16877         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
16878         int level;
16879         level = ndr_pull_get_switch_value(ndr, r);
16880         if (ndr_flags & NDR_SCALARS) {
16881                 switch (level) {
16882                         case 1: {
16883                                 NDR_CHECK(ndr_pull_align(ndr, 4));
16884                                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
16885                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_SCALARS, &r->info1));
16886                         break; }
16887
16888                         default: {
16889                         break; }
16890
16891                 }
16892         }
16893         if (ndr_flags & NDR_BUFFERS) {
16894                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
16895                 switch (level) {
16896                         case 1:
16897                                 NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo1(ndr, NDR_BUFFERS, &r->info1));
16898                         break;
16899
16900                         default:
16901                         break;
16902
16903                 }
16904         }
16905         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
16906         return NDR_ERR_SUCCESS;
16907 }
16908
16909 _PUBLIC_ void ndr_print_spoolss_PrintProcDataTypesInfo(struct ndr_print *ndr, const char *name, const union spoolss_PrintProcDataTypesInfo *r)
16910 {
16911         int level;
16912         level = ndr_print_get_switch_value(ndr, r);
16913         ndr_print_union(ndr, name, level, "spoolss_PrintProcDataTypesInfo");
16914         switch (level) {
16915                 case 1:
16916                         ndr_print_spoolss_PrintProcDataTypesInfo1(ndr, "info1", &r->info1);
16917                 break;
16918
16919                 default:
16920                 break;
16921
16922         }
16923 }
16924
16925 static enum ndr_err_code ndr_push_spoolss_PrinterChangeFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
16926 {
16927         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
16928         return NDR_ERR_SUCCESS;
16929 }
16930
16931 static enum ndr_err_code ndr_pull_spoolss_PrinterChangeFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
16932 {
16933         uint32_t v;
16934         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
16935         *r = v;
16936         return NDR_ERR_SUCCESS;
16937 }
16938
16939 _PUBLIC_ void ndr_print_spoolss_PrinterChangeFlags(struct ndr_print *ndr, const char *name, uint32_t r)
16940 {
16941         ndr_print_uint32(ndr, name, r);
16942         ndr->depth++;
16943         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER", PRINTER_CHANGE_ADD_PRINTER, r);
16944         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER", PRINTER_CHANGE_SET_PRINTER, r);
16945         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER", PRINTER_CHANGE_DELETE_PRINTER, r);
16946         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_FAILED_CONNECTION_PRINTER", PRINTER_CHANGE_FAILED_CONNECTION_PRINTER, r);
16947         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_JOB", PRINTER_CHANGE_ADD_JOB, r);
16948         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_JOB", PRINTER_CHANGE_SET_JOB, r);
16949         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_JOB", PRINTER_CHANGE_DELETE_JOB, r);
16950         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_WRITE_JOB", PRINTER_CHANGE_WRITE_JOB, r);
16951         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_FORM", PRINTER_CHANGE_ADD_FORM, r);
16952         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_FORM", PRINTER_CHANGE_SET_FORM, r);
16953         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_FORM", PRINTER_CHANGE_DELETE_FORM, r);
16954         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PORT", PRINTER_CHANGE_ADD_PORT, r);
16955         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_CONFIGURE_PORT", PRINTER_CHANGE_CONFIGURE_PORT, r);
16956         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PORT", PRINTER_CHANGE_DELETE_PORT, r);
16957         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINT_PROCESSOR", PRINTER_CHANGE_ADD_PRINT_PROCESSOR, r);
16958         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINT_PROCESSOR", PRINTER_CHANGE_DELETE_PRINT_PROCESSOR, r);
16959         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SERVER", PRINTER_CHANGE_SERVER, r);
16960         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_ADD_PRINTER_DRIVER", PRINTER_CHANGE_ADD_PRINTER_DRIVER, r);
16961         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_SET_PRINTER_DRIVER", PRINTER_CHANGE_SET_PRINTER_DRIVER, r);
16962         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_DELETE_PRINTER_DRIVER", PRINTER_CHANGE_DELETE_PRINTER_DRIVER, r);
16963         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_CHANGE_TIMEOUT", PRINTER_CHANGE_TIMEOUT, r);
16964         ndr->depth--;
16965 }
16966
16967 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_JobNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_JobNotifyField r)
16968 {
16969         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16970         return NDR_ERR_SUCCESS;
16971 }
16972
16973 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_JobNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_JobNotifyField *r)
16974 {
16975         uint16_t v;
16976         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
16977         *r = v;
16978         return NDR_ERR_SUCCESS;
16979 }
16980
16981 _PUBLIC_ void ndr_print_spoolss_JobNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_JobNotifyField r)
16982 {
16983         const char *val = NULL;
16984
16985         switch (r) {
16986                 case JOB_NOTIFY_FIELD_PRINTER_NAME: val = "JOB_NOTIFY_FIELD_PRINTER_NAME"; break;
16987                 case JOB_NOTIFY_FIELD_MACHINE_NAME: val = "JOB_NOTIFY_FIELD_MACHINE_NAME"; break;
16988                 case JOB_NOTIFY_FIELD_PORT_NAME: val = "JOB_NOTIFY_FIELD_PORT_NAME"; break;
16989                 case JOB_NOTIFY_FIELD_USER_NAME: val = "JOB_NOTIFY_FIELD_USER_NAME"; break;
16990                 case JOB_NOTIFY_FIELD_NOTIFY_NAME: val = "JOB_NOTIFY_FIELD_NOTIFY_NAME"; break;
16991                 case JOB_NOTIFY_FIELD_DATATYPE: val = "JOB_NOTIFY_FIELD_DATATYPE"; break;
16992                 case JOB_NOTIFY_FIELD_PRINT_PROCESSOR: val = "JOB_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
16993                 case JOB_NOTIFY_FIELD_PARAMETERS: val = "JOB_NOTIFY_FIELD_PARAMETERS"; break;
16994                 case JOB_NOTIFY_FIELD_DRIVER_NAME: val = "JOB_NOTIFY_FIELD_DRIVER_NAME"; break;
16995                 case JOB_NOTIFY_FIELD_DEVMODE: val = "JOB_NOTIFY_FIELD_DEVMODE"; break;
16996                 case JOB_NOTIFY_FIELD_STATUS: val = "JOB_NOTIFY_FIELD_STATUS"; break;
16997                 case JOB_NOTIFY_FIELD_STATUS_STRING: val = "JOB_NOTIFY_FIELD_STATUS_STRING"; break;
16998                 case JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "JOB_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
16999                 case JOB_NOTIFY_FIELD_DOCUMENT: val = "JOB_NOTIFY_FIELD_DOCUMENT"; break;
17000                 case JOB_NOTIFY_FIELD_PRIORITY: val = "JOB_NOTIFY_FIELD_PRIORITY"; break;
17001                 case JOB_NOTIFY_FIELD_POSITION: val = "JOB_NOTIFY_FIELD_POSITION"; break;
17002                 case JOB_NOTIFY_FIELD_SUBMITTED: val = "JOB_NOTIFY_FIELD_SUBMITTED"; break;
17003                 case JOB_NOTIFY_FIELD_START_TIME: val = "JOB_NOTIFY_FIELD_START_TIME"; break;
17004                 case JOB_NOTIFY_FIELD_UNTIL_TIME: val = "JOB_NOTIFY_FIELD_UNTIL_TIME"; break;
17005                 case JOB_NOTIFY_FIELD_TIME: val = "JOB_NOTIFY_FIELD_TIME"; break;
17006                 case JOB_NOTIFY_FIELD_TOTAL_PAGES: val = "JOB_NOTIFY_FIELD_TOTAL_PAGES"; break;
17007                 case JOB_NOTIFY_FIELD_PAGES_PRINTED: val = "JOB_NOTIFY_FIELD_PAGES_PRINTED"; break;
17008                 case JOB_NOTIFY_FIELD_TOTAL_BYTES: val = "JOB_NOTIFY_FIELD_TOTAL_BYTES"; break;
17009                 case JOB_NOTIFY_FIELD_BYTES_PRINTED: val = "JOB_NOTIFY_FIELD_BYTES_PRINTED"; break;
17010         }
17011         ndr_print_enum(ndr, name, "ENUM", val, r);
17012 }
17013
17014 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrintNotifyField(struct ndr_push *ndr, int ndr_flags, enum spoolss_PrintNotifyField r)
17015 {
17016         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17017         return NDR_ERR_SUCCESS;
17018 }
17019
17020 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrintNotifyField(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PrintNotifyField *r)
17021 {
17022         uint16_t v;
17023         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17024         *r = v;
17025         return NDR_ERR_SUCCESS;
17026 }
17027
17028 _PUBLIC_ void ndr_print_spoolss_PrintNotifyField(struct ndr_print *ndr, const char *name, enum spoolss_PrintNotifyField r)
17029 {
17030         const char *val = NULL;
17031
17032         switch (r) {
17033                 case PRINTER_NOTIFY_FIELD_SERVER_NAME: val = "PRINTER_NOTIFY_FIELD_SERVER_NAME"; break;
17034                 case PRINTER_NOTIFY_FIELD_PRINTER_NAME: val = "PRINTER_NOTIFY_FIELD_PRINTER_NAME"; break;
17035                 case PRINTER_NOTIFY_FIELD_SHARE_NAME: val = "PRINTER_NOTIFY_FIELD_SHARE_NAME"; break;
17036                 case PRINTER_NOTIFY_FIELD_PORT_NAME: val = "PRINTER_NOTIFY_FIELD_PORT_NAME"; break;
17037                 case PRINTER_NOTIFY_FIELD_DRIVER_NAME: val = "PRINTER_NOTIFY_FIELD_DRIVER_NAME"; break;
17038                 case PRINTER_NOTIFY_FIELD_COMMENT: val = "PRINTER_NOTIFY_FIELD_COMMENT"; break;
17039                 case PRINTER_NOTIFY_FIELD_LOCATION: val = "PRINTER_NOTIFY_FIELD_LOCATION"; break;
17040                 case PRINTER_NOTIFY_FIELD_DEVMODE: val = "PRINTER_NOTIFY_FIELD_DEVMODE"; break;
17041                 case PRINTER_NOTIFY_FIELD_SEPFILE: val = "PRINTER_NOTIFY_FIELD_SEPFILE"; break;
17042                 case PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR: val = "PRINTER_NOTIFY_FIELD_PRINT_PROCESSOR"; break;
17043                 case PRINTER_NOTIFY_FIELD_PARAMETERS: val = "PRINTER_NOTIFY_FIELD_PARAMETERS"; break;
17044                 case PRINTER_NOTIFY_FIELD_DATATYPE: val = "PRINTER_NOTIFY_FIELD_DATATYPE"; break;
17045                 case PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR: val = "PRINTER_NOTIFY_FIELD_SECURITY_DESCRIPTOR"; break;
17046                 case PRINTER_NOTIFY_FIELD_ATTRIBUTES: val = "PRINTER_NOTIFY_FIELD_ATTRIBUTES"; break;
17047                 case PRINTER_NOTIFY_FIELD_PRIORITY: val = "PRINTER_NOTIFY_FIELD_PRIORITY"; break;
17048                 case PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY: val = "PRINTER_NOTIFY_FIELD_DEFAULT_PRIORITY"; break;
17049                 case PRINTER_NOTIFY_FIELD_START_TIME: val = "PRINTER_NOTIFY_FIELD_START_TIME"; break;
17050                 case PRINTER_NOTIFY_FIELD_UNTIL_TIME: val = "PRINTER_NOTIFY_FIELD_UNTIL_TIME"; break;
17051                 case PRINTER_NOTIFY_FIELD_STATUS: val = "PRINTER_NOTIFY_FIELD_STATUS"; break;
17052                 case PRINTER_NOTIFY_FIELD_STATUS_STRING: val = "PRINTER_NOTIFY_FIELD_STATUS_STRING"; break;
17053                 case PRINTER_NOTIFY_FIELD_CJOBS: val = "PRINTER_NOTIFY_FIELD_CJOBS"; break;
17054                 case PRINTER_NOTIFY_FIELD_AVERAGE_PPM: val = "PRINTER_NOTIFY_FIELD_AVERAGE_PPM"; break;
17055                 case PRINTER_NOTIFY_FIELD_TOTAL_PAGES: val = "PRINTER_NOTIFY_FIELD_TOTAL_PAGES"; break;
17056                 case PRINTER_NOTIFY_FIELD_PAGES_PRINTED: val = "PRINTER_NOTIFY_FIELD_PAGES_PRINTED"; break;
17057                 case PRINTER_NOTIFY_FIELD_TOTAL_BYTES: val = "PRINTER_NOTIFY_FIELD_TOTAL_BYTES"; break;
17058                 case PRINTER_NOTIFY_FIELD_BYTES_PRINTED: val = "PRINTER_NOTIFY_FIELD_BYTES_PRINTED"; break;
17059                 case PRINTER_NOTIFY_FIELD_OBJECT_GUID: val = "PRINTER_NOTIFY_FIELD_OBJECT_GUID"; break;
17060                 case PRINTER_NOTIFY_FIELD_FRIENDLY_NAME: val = "PRINTER_NOTIFY_FIELD_FRIENDLY_NAME"; break;
17061         }
17062         ndr_print_enum(ndr, name, "ENUM", val, r);
17063 }
17064
17065 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17066 {
17067         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17068         return NDR_ERR_SUCCESS;
17069 }
17070
17071 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17072 {
17073         uint16_t v;
17074         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17075         *r = v;
17076         return NDR_ERR_SUCCESS;
17077 }
17078
17079 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17080 {
17081         const char *val = NULL;
17082
17083         switch (r) {
17084                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17085                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17086         }
17087         ndr_print_enum(ndr, name, "ENUM", val, r);
17088 }
17089
17090 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, const union spoolss_Field *r)
17091 {
17092         if (ndr_flags & NDR_SCALARS) {
17093                 int level = ndr_push_get_switch_value(ndr, r);
17094                 switch (level) {
17095                         case PRINTER_NOTIFY_TYPE: {
17096                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17097                         break; }
17098
17099                         case JOB_NOTIFY_TYPE: {
17100                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17101                         break; }
17102
17103                         default: {
17104                                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->field));
17105                         break; }
17106
17107                 }
17108         }
17109         if (ndr_flags & NDR_BUFFERS) {
17110                 int level = ndr_push_get_switch_value(ndr, r);
17111                 switch (level) {
17112                         case PRINTER_NOTIFY_TYPE:
17113                         break;
17114
17115                         case JOB_NOTIFY_TYPE:
17116                         break;
17117
17118                         default:
17119                         break;
17120
17121                 }
17122         }
17123         return NDR_ERR_SUCCESS;
17124 }
17125
17126 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, union spoolss_Field *r)
17127 {
17128         int level;
17129         level = ndr_pull_get_switch_value(ndr, r);
17130         if (ndr_flags & NDR_SCALARS) {
17131                 switch (level) {
17132                         case PRINTER_NOTIFY_TYPE: {
17133                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17134                         break; }
17135
17136                         case JOB_NOTIFY_TYPE: {
17137                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17138                         break; }
17139
17140                         default: {
17141                                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->field));
17142                         break; }
17143
17144                 }
17145         }
17146         if (ndr_flags & NDR_BUFFERS) {
17147                 switch (level) {
17148                         case PRINTER_NOTIFY_TYPE:
17149                         break;
17150
17151                         case JOB_NOTIFY_TYPE:
17152                         break;
17153
17154                         default:
17155                         break;
17156
17157                 }
17158         }
17159         return NDR_ERR_SUCCESS;
17160 }
17161
17162 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17163 {
17164         uint32_t cntr_fields_1;
17165         if (ndr_flags & NDR_SCALARS) {
17166                 NDR_CHECK(ndr_push_align(ndr, 4));
17167                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17168                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17170                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17172                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17173         }
17174         if (ndr_flags & NDR_BUFFERS) {
17175                 if (r->fields) {
17176                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17177                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17178                                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17179                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17180                         }
17181                 }
17182         }
17183         return NDR_ERR_SUCCESS;
17184 }
17185
17186 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17187 {
17188         uint32_t _ptr_fields;
17189         uint32_t cntr_fields_1;
17190         TALLOC_CTX *_mem_save_fields_0;
17191         TALLOC_CTX *_mem_save_fields_1;
17192         if (ndr_flags & NDR_SCALARS) {
17193                 NDR_CHECK(ndr_pull_align(ndr, 4));
17194                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17195                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17196                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17197                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17198                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17199                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17200                 if (_ptr_fields) {
17201                         NDR_PULL_ALLOC(ndr, r->fields);
17202                 } else {
17203                         r->fields = NULL;
17204                 }
17205         }
17206         if (ndr_flags & NDR_BUFFERS) {
17207                 if (r->fields) {
17208                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17209                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17210                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17211                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17212                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17213                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17214                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17215                                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type));
17216                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17217                         }
17218                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17219                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17220                 }
17221                 if (r->fields) {
17222                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17223                 }
17224         }
17225         return NDR_ERR_SUCCESS;
17226 }
17227
17228 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17229 {
17230         uint32_t cntr_fields_1;
17231         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17232         ndr->depth++;
17233         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17234         ndr_print_uint16(ndr, "u1", r->u1);
17235         ndr_print_uint32(ndr, "u2", r->u2);
17236         ndr_print_uint32(ndr, "u3", r->u3);
17237         ndr_print_uint32(ndr, "count", r->count);
17238         ndr_print_ptr(ndr, "fields", r->fields);
17239         ndr->depth++;
17240         if (r->fields) {
17241                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17242                 ndr->depth++;
17243                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17244                         char *idx_1=NULL;
17245                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17246                                 ndr_print_set_switch_value(ndr, &r->fields[cntr_fields_1], r->type);
17247                                 ndr_print_spoolss_Field(ndr, "fields", &r->fields[cntr_fields_1]);
17248                                 free(idx_1);
17249                         }
17250                 }
17251                 ndr->depth--;
17252         }
17253         ndr->depth--;
17254         ndr->depth--;
17255 }
17256
17257 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17258 {
17259         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17260         return NDR_ERR_SUCCESS;
17261 }
17262
17263 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17264 {
17265         uint32_t v;
17266         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17267         *r = v;
17268         return NDR_ERR_SUCCESS;
17269 }
17270
17271 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17272 {
17273         ndr_print_uint32(ndr, name, r);
17274         ndr->depth++;
17275         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17276         ndr->depth--;
17277 }
17278
17279 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17280 {
17281         uint32_t cntr_types_1;
17282         if (ndr_flags & NDR_SCALARS) {
17283                 NDR_CHECK(ndr_push_align(ndr, 4));
17284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17285                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17286                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17287                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17288         }
17289         if (ndr_flags & NDR_BUFFERS) {
17290                 if (r->types) {
17291                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17292                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17293                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17294                         }
17295                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17296                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17297                         }
17298                 }
17299         }
17300         return NDR_ERR_SUCCESS;
17301 }
17302
17303 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17304 {
17305         uint32_t _ptr_types;
17306         uint32_t cntr_types_1;
17307         TALLOC_CTX *_mem_save_types_0;
17308         TALLOC_CTX *_mem_save_types_1;
17309         if (ndr_flags & NDR_SCALARS) {
17310                 NDR_CHECK(ndr_pull_align(ndr, 4));
17311                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17312                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17314                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17315                 if (_ptr_types) {
17316                         NDR_PULL_ALLOC(ndr, r->types);
17317                 } else {
17318                         r->types = NULL;
17319                 }
17320         }
17321         if (ndr_flags & NDR_BUFFERS) {
17322                 if (r->types) {
17323                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17324                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17325                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17326                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17327                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17328                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17329                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17330                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17331                         }
17332                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17333                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17334                         }
17335                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17336                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17337                 }
17338                 if (r->types) {
17339                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17340                 }
17341         }
17342         return NDR_ERR_SUCCESS;
17343 }
17344
17345 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17346 {
17347         uint32_t cntr_types_1;
17348         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17349         ndr->depth++;
17350         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17351         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17352         ndr_print_uint32(ndr, "count", r->count);
17353         ndr_print_ptr(ndr, "types", r->types);
17354         ndr->depth++;
17355         if (r->types) {
17356                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17357                 ndr->depth++;
17358                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17359                         char *idx_1=NULL;
17360                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17361                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17362                                 free(idx_1);
17363                         }
17364                 }
17365                 ndr->depth--;
17366         }
17367         ndr->depth--;
17368         ndr->depth--;
17369 }
17370
17371 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17372 {
17373         if (ndr_flags & NDR_SCALARS) {
17374                 NDR_CHECK(ndr_push_align(ndr, 4));
17375                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17376                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17377         }
17378         if (ndr_flags & NDR_BUFFERS) {
17379                 if (r->string) {
17380                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17381                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17382                 }
17383         }
17384         return NDR_ERR_SUCCESS;
17385 }
17386
17387 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17388 {
17389         uint32_t _ptr_string;
17390         TALLOC_CTX *_mem_save_string_0;
17391         if (ndr_flags & NDR_SCALARS) {
17392                 NDR_CHECK(ndr_pull_align(ndr, 4));
17393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17394                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17395                 if (_ptr_string) {
17396                         NDR_PULL_ALLOC(ndr, r->string);
17397                 } else {
17398                         r->string = NULL;
17399                 }
17400         }
17401         if (ndr_flags & NDR_BUFFERS) {
17402                 if (r->string) {
17403                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17404                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17405                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17406                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17408                 }
17409                 if (r->string) {
17410                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17411                 }
17412         }
17413         return NDR_ERR_SUCCESS;
17414 }
17415
17416 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17417 {
17418         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17419         ndr->depth++;
17420         ndr_print_uint32(ndr, "size", r->size);
17421         ndr_print_ptr(ndr, "string", r->string);
17422         ndr->depth++;
17423         if (r->string) {
17424                 ndr_print_string(ndr, "string", r->string);
17425         }
17426         ndr->depth--;
17427         ndr->depth--;
17428 }
17429
17430 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17431 {
17432         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17433         return NDR_ERR_SUCCESS;
17434 }
17435
17436 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17437 {
17438         uint32_t v;
17439         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17440         *r = v;
17441         return NDR_ERR_SUCCESS;
17442 }
17443
17444 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17445 {
17446         const char *val = NULL;
17447
17448         switch (r) {
17449                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17450                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17451                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17452                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17453                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17454         }
17455         ndr_print_enum(ndr, name, "ENUM", val, r);
17456 }
17457
17458 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17459 {
17460         if (ndr_flags & NDR_SCALARS) {
17461                 int level = ndr_push_get_switch_value(ndr, r);
17462                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17463                 switch (level) {
17464                         case 1: {
17465                                 uint32_t cntr_integer_0;
17466                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17467                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17468                                 }
17469                         break; }
17470
17471                         case 2: {
17472                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17473                         break; }
17474
17475                         case 3: {
17476                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17477                         break; }
17478
17479                         case 4: {
17480                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17481                         break; }
17482
17483                         case 5: {
17484                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17485                         break; }
17486
17487                         default:
17488                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17489                 }
17490         }
17491         if (ndr_flags & NDR_BUFFERS) {
17492                 int level = ndr_push_get_switch_value(ndr, r);
17493                 switch (level) {
17494                         case 1:
17495                         break;
17496
17497                         case 2:
17498                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17499                         break;
17500
17501                         case 3:
17502                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17503                         break;
17504
17505                         case 4:
17506                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17507                         break;
17508
17509                         case 5:
17510                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17511                         break;
17512
17513                         default:
17514                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17515                 }
17516         }
17517         return NDR_ERR_SUCCESS;
17518 }
17519
17520 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17521 {
17522         int level;
17523         uint32_t _level;
17524         level = ndr_pull_get_switch_value(ndr, r);
17525         if (ndr_flags & NDR_SCALARS) {
17526                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17527                 if (_level != level) {
17528                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17529                 }
17530                 switch (level) {
17531                         case 1: {
17532                                 uint32_t cntr_integer_0;
17533                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17534                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17535                                 }
17536                         break; }
17537
17538                         case 2: {
17539                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17540                         break; }
17541
17542                         case 3: {
17543                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17544                         break; }
17545
17546                         case 4: {
17547                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17548                         break; }
17549
17550                         case 5: {
17551                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17552                         break; }
17553
17554                         default:
17555                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17556                 }
17557         }
17558         if (ndr_flags & NDR_BUFFERS) {
17559                 switch (level) {
17560                         case 1:
17561                         break;
17562
17563                         case 2:
17564                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17565                         break;
17566
17567                         case 3:
17568                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17569                         break;
17570
17571                         case 4:
17572                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17573                         break;
17574
17575                         case 5:
17576                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17577                         break;
17578
17579                         default:
17580                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17581                 }
17582         }
17583         return NDR_ERR_SUCCESS;
17584 }
17585
17586 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17587 {
17588         int level;
17589         uint32_t cntr_integer_0;
17590         level = ndr_print_get_switch_value(ndr, r);
17591         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17592         switch (level) {
17593                 case 1:
17594                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17595                         ndr->depth++;
17596                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17597                                 char *idx_0=NULL;
17598                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17599                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17600                                         free(idx_0);
17601                                 }
17602                         }
17603                         ndr->depth--;
17604                 break;
17605
17606                 case 2:
17607                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17608                 break;
17609
17610                 case 3:
17611                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17612                 break;
17613
17614                 case 4:
17615                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17616                 break;
17617
17618                 case 5:
17619                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17620                 break;
17621
17622                 default:
17623                         ndr_print_bad_level(ndr, name, level);
17624         }
17625 }
17626
17627 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17628 {
17629         if (ndr_flags & NDR_SCALARS) {
17630                 NDR_CHECK(ndr_push_align(ndr, 4));
17631                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17632                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->field, r->type));
17633                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17634                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17636                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17637                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17638         }
17639         if (ndr_flags & NDR_BUFFERS) {
17640                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17641         }
17642         return NDR_ERR_SUCCESS;
17643 }
17644
17645 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17646 {
17647         if (ndr_flags & NDR_SCALARS) {
17648                 NDR_CHECK(ndr_pull_align(ndr, 4));
17649                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17650                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->field, r->type));
17651                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17652                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17654                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17655                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17656         }
17657         if (ndr_flags & NDR_BUFFERS) {
17658                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17659         }
17660         return NDR_ERR_SUCCESS;
17661 }
17662
17663 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17664 {
17665         ndr_print_struct(ndr, name, "spoolss_Notify");
17666         ndr->depth++;
17667         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17668         ndr_print_set_switch_value(ndr, &r->field, r->type);
17669         ndr_print_spoolss_Field(ndr, "field", &r->field);
17670         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17671         ndr_print_uint32(ndr, "job_id", r->job_id);
17672         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17673         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17674         ndr->depth--;
17675 }
17676
17677 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17678 {
17679         uint32_t cntr_notifies_0;
17680         if (ndr_flags & NDR_SCALARS) {
17681                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17682                 NDR_CHECK(ndr_push_align(ndr, 4));
17683                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17685                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17686                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17687                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17688                 }
17689         }
17690         if (ndr_flags & NDR_BUFFERS) {
17691                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17692                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17693                 }
17694         }
17695         return NDR_ERR_SUCCESS;
17696 }
17697
17698 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17699 {
17700         uint32_t cntr_notifies_0;
17701         TALLOC_CTX *_mem_save_notifies_0;
17702         if (ndr_flags & NDR_SCALARS) {
17703                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17704                 NDR_CHECK(ndr_pull_align(ndr, 4));
17705                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17707                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17708                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17709                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17710                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17711                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17712                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17713                 }
17714                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17715                 if (r->notifies) {
17716                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17717                 }
17718         }
17719         if (ndr_flags & NDR_BUFFERS) {
17720                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17721                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17722                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17723                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17724                 }
17725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17726         }
17727         return NDR_ERR_SUCCESS;
17728 }
17729
17730 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17731 {
17732         uint32_t cntr_notifies_0;
17733         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17734         ndr->depth++;
17735         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17736         ndr_print_uint32(ndr, "flags", r->flags);
17737         ndr_print_uint32(ndr, "count", r->count);
17738         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17739         ndr->depth++;
17740         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17741                 char *idx_0=NULL;
17742                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17743                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17744                         free(idx_0);
17745                 }
17746         }
17747         ndr->depth--;
17748         ndr->depth--;
17749 }
17750
17751 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17752 {
17753         if (ndr_flags & NDR_SCALARS) {
17754                 int level = ndr_push_get_switch_value(ndr, r);
17755                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17756                 switch (level) {
17757                         case 0: {
17758                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17759                         break; }
17760
17761                         default:
17762                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17763                 }
17764         }
17765         if (ndr_flags & NDR_BUFFERS) {
17766                 int level = ndr_push_get_switch_value(ndr, r);
17767                 switch (level) {
17768                         case 0:
17769                                 if (r->info0) {
17770                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17771                                 }
17772                         break;
17773
17774                         default:
17775                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17776                 }
17777         }
17778         return NDR_ERR_SUCCESS;
17779 }
17780
17781 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17782 {
17783         int level;
17784         uint32_t _level;
17785         TALLOC_CTX *_mem_save_info0_0;
17786         level = ndr_pull_get_switch_value(ndr, r);
17787         if (ndr_flags & NDR_SCALARS) {
17788                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17789                 if (_level != level) {
17790                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17791                 }
17792                 switch (level) {
17793                         case 0: {
17794                                 uint32_t _ptr_info0;
17795                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17796                                 if (_ptr_info0) {
17797                                         NDR_PULL_ALLOC(ndr, r->info0);
17798                                 } else {
17799                                         r->info0 = NULL;
17800                                 }
17801                         break; }
17802
17803                         default:
17804                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17805                 }
17806         }
17807         if (ndr_flags & NDR_BUFFERS) {
17808                 switch (level) {
17809                         case 0:
17810                                 if (r->info0) {
17811                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17812                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17813                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17814                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17815                                 }
17816                         break;
17817
17818                         default:
17819                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17820                 }
17821         }
17822         return NDR_ERR_SUCCESS;
17823 }
17824
17825 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17826 {
17827         int level;
17828         level = ndr_print_get_switch_value(ndr, r);
17829         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17830         switch (level) {
17831                 case 0:
17832                         ndr_print_ptr(ndr, "info0", r->info0);
17833                         ndr->depth++;
17834                         if (r->info0) {
17835                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17836                         }
17837                         ndr->depth--;
17838                 break;
17839
17840                 default:
17841                         ndr_print_bad_level(ndr, name, level);
17842         }
17843 }
17844
17845 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17846 {
17847         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17848         return NDR_ERR_SUCCESS;
17849 }
17850
17851 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17852 {
17853         uint32_t v;
17854         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17855         *r = v;
17856         return NDR_ERR_SUCCESS;
17857 }
17858
17859 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17860 {
17861         ndr_print_uint32(ndr, name, r);
17862         ndr->depth++;
17863         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17864         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17865         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17866         ndr->depth--;
17867 }
17868
17869 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17870 {
17871         if (ndr_flags & NDR_SCALARS) {
17872                 NDR_CHECK(ndr_push_align(ndr, 4));
17873                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17874                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17875                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17876                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17877                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17878                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17879                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17880         }
17881         if (ndr_flags & NDR_BUFFERS) {
17882                 if (r->client) {
17883                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17884                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17885                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17886                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17887                 }
17888                 if (r->user) {
17889                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17890                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17891                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17892                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17893                 }
17894         }
17895         return NDR_ERR_SUCCESS;
17896 }
17897
17898 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17899 {
17900         uint32_t _ptr_client;
17901         TALLOC_CTX *_mem_save_client_0;
17902         uint32_t _ptr_user;
17903         TALLOC_CTX *_mem_save_user_0;
17904         if (ndr_flags & NDR_SCALARS) {
17905                 NDR_CHECK(ndr_pull_align(ndr, 4));
17906                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17907                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17908                 if (_ptr_client) {
17909                         NDR_PULL_ALLOC(ndr, r->client);
17910                 } else {
17911                         r->client = NULL;
17912                 }
17913                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17914                 if (_ptr_user) {
17915                         NDR_PULL_ALLOC(ndr, r->user);
17916                 } else {
17917                         r->user = NULL;
17918                 }
17919                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17920                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17921                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17922                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17923         }
17924         if (ndr_flags & NDR_BUFFERS) {
17925                 if (r->client) {
17926                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17927                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17928                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17929                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17930                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17931                                 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));
17932                         }
17933                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17934                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17935                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17936                 }
17937                 if (r->user) {
17938                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17939                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17940                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17941                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17942                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17943                                 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));
17944                         }
17945                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17946                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17947                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17948                 }
17949         }
17950         return NDR_ERR_SUCCESS;
17951 }
17952
17953 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17954 {
17955         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17956         ndr->depth++;
17957         ndr_print_uint32(ndr, "size", r->size);
17958         ndr_print_ptr(ndr, "client", r->client);
17959         ndr->depth++;
17960         if (r->client) {
17961                 ndr_print_string(ndr, "client", r->client);
17962         }
17963         ndr->depth--;
17964         ndr_print_ptr(ndr, "user", r->user);
17965         ndr->depth++;
17966         if (r->user) {
17967                 ndr_print_string(ndr, "user", r->user);
17968         }
17969         ndr->depth--;
17970         ndr_print_uint32(ndr, "build", r->build);
17971         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17972         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17973         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17974         ndr->depth--;
17975 }
17976
17977 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17978 {
17979         if (ndr_flags & NDR_SCALARS) {
17980                 NDR_CHECK(ndr_push_align(ndr, 4));
17981                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17982         }
17983         if (ndr_flags & NDR_BUFFERS) {
17984         }
17985         return NDR_ERR_SUCCESS;
17986 }
17987
17988 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17989 {
17990         if (ndr_flags & NDR_SCALARS) {
17991                 NDR_CHECK(ndr_pull_align(ndr, 4));
17992                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17993         }
17994         if (ndr_flags & NDR_BUFFERS) {
17995         }
17996         return NDR_ERR_SUCCESS;
17997 }
17998
17999 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
18000 {
18001         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
18002         ndr->depth++;
18003         ndr_print_uint32(ndr, "not_used", r->not_used);
18004         ndr->depth--;
18005 }
18006
18007 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
18008 {
18009         if (ndr_flags & NDR_SCALARS) {
18010                 NDR_CHECK(ndr_push_align(ndr, 4));
18011                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
18012                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
18013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
18014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
18015                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
18016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
18017                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
18018                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
18019                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
18020                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
18021         }
18022         if (ndr_flags & NDR_BUFFERS) {
18023                 if (r->client) {
18024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18026                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
18027                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18028                 }
18029                 if (r->user) {
18030                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18031                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18032                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
18033                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18034                 }
18035         }
18036         return NDR_ERR_SUCCESS;
18037 }
18038
18039 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
18040 {
18041         uint32_t _ptr_client;
18042         TALLOC_CTX *_mem_save_client_0;
18043         uint32_t _ptr_user;
18044         TALLOC_CTX *_mem_save_user_0;
18045         if (ndr_flags & NDR_SCALARS) {
18046                 NDR_CHECK(ndr_pull_align(ndr, 4));
18047                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
18049                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
18050                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
18051                 if (_ptr_client) {
18052                         NDR_PULL_ALLOC(ndr, r->client);
18053                 } else {
18054                         r->client = NULL;
18055                 }
18056                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
18057                 if (_ptr_user) {
18058                         NDR_PULL_ALLOC(ndr, r->user);
18059                 } else {
18060                         r->user = NULL;
18061                 }
18062                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
18063                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
18064                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
18065                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
18066                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
18067         }
18068         if (ndr_flags & NDR_BUFFERS) {
18069                 if (r->client) {
18070                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
18071                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
18072                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
18073                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
18074                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
18075                                 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));
18076                         }
18077                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
18078                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
18079                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
18080                 }
18081                 if (r->user) {
18082                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
18083                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
18084                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
18085                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
18086                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
18087                                 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));
18088                         }
18089                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
18090                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
18091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
18092                 }
18093         }
18094         return NDR_ERR_SUCCESS;
18095 }
18096
18097 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
18098 {
18099         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
18100         ndr->depth++;
18101         ndr_print_uint32(ndr, "size", r->size);
18102         ndr_print_uint32(ndr, "flags", r->flags);
18103         ndr_print_uint32(ndr, "size2", r->size2);
18104         ndr_print_ptr(ndr, "client", r->client);
18105         ndr->depth++;
18106         if (r->client) {
18107                 ndr_print_string(ndr, "client", r->client);
18108         }
18109         ndr->depth--;
18110         ndr_print_ptr(ndr, "user", r->user);
18111         ndr->depth++;
18112         if (r->user) {
18113                 ndr_print_string(ndr, "user", r->user);
18114         }
18115         ndr->depth--;
18116         ndr_print_uint32(ndr, "build", r->build);
18117         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
18118         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
18119         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
18120         ndr_print_udlong(ndr, "reserved", r->reserved);
18121         ndr->depth--;
18122 }
18123
18124 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
18125 {
18126         if (ndr_flags & NDR_SCALARS) {
18127                 int level = ndr_push_get_switch_value(ndr, r);
18128                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18129                 switch (level) {
18130                         case 1: {
18131                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18132                         break; }
18133
18134                         case 2: {
18135                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18136                         break; }
18137
18138                         case 3: {
18139                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18140                         break; }
18141
18142                         default:
18143                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18144                 }
18145         }
18146         if (ndr_flags & NDR_BUFFERS) {
18147                 int level = ndr_push_get_switch_value(ndr, r);
18148                 switch (level) {
18149                         case 1:
18150                                 if (r->level1) {
18151                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18152                                 }
18153                         break;
18154
18155                         case 2:
18156                                 if (r->level2) {
18157                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18158                                 }
18159                         break;
18160
18161                         case 3:
18162                                 if (r->level3) {
18163                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18164                                 }
18165                         break;
18166
18167                         default:
18168                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18169                 }
18170         }
18171         return NDR_ERR_SUCCESS;
18172 }
18173
18174 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18175 {
18176         int level;
18177         uint32_t _level;
18178         TALLOC_CTX *_mem_save_level1_0;
18179         TALLOC_CTX *_mem_save_level2_0;
18180         TALLOC_CTX *_mem_save_level3_0;
18181         level = ndr_pull_get_switch_value(ndr, r);
18182         if (ndr_flags & NDR_SCALARS) {
18183                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18184                 if (_level != level) {
18185                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18186                 }
18187                 switch (level) {
18188                         case 1: {
18189                                 uint32_t _ptr_level1;
18190                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18191                                 if (_ptr_level1) {
18192                                         NDR_PULL_ALLOC(ndr, r->level1);
18193                                 } else {
18194                                         r->level1 = NULL;
18195                                 }
18196                         break; }
18197
18198                         case 2: {
18199                                 uint32_t _ptr_level2;
18200                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18201                                 if (_ptr_level2) {
18202                                         NDR_PULL_ALLOC(ndr, r->level2);
18203                                 } else {
18204                                         r->level2 = NULL;
18205                                 }
18206                         break; }
18207
18208                         case 3: {
18209                                 uint32_t _ptr_level3;
18210                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18211                                 if (_ptr_level3) {
18212                                         NDR_PULL_ALLOC(ndr, r->level3);
18213                                 } else {
18214                                         r->level3 = NULL;
18215                                 }
18216                         break; }
18217
18218                         default:
18219                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18220                 }
18221         }
18222         if (ndr_flags & NDR_BUFFERS) {
18223                 switch (level) {
18224                         case 1:
18225                                 if (r->level1) {
18226                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18227                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18228                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18229                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18230                                 }
18231                         break;
18232
18233                         case 2:
18234                                 if (r->level2) {
18235                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18236                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18237                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18238                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18239                                 }
18240                         break;
18241
18242                         case 3:
18243                                 if (r->level3) {
18244                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18245                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18246                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18247                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18248                                 }
18249                         break;
18250
18251                         default:
18252                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18253                 }
18254         }
18255         return NDR_ERR_SUCCESS;
18256 }
18257
18258 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18259 {
18260         int level;
18261         level = ndr_print_get_switch_value(ndr, r);
18262         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18263         switch (level) {
18264                 case 1:
18265                         ndr_print_ptr(ndr, "level1", r->level1);
18266                         ndr->depth++;
18267                         if (r->level1) {
18268                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18269                         }
18270                         ndr->depth--;
18271                 break;
18272
18273                 case 2:
18274                         ndr_print_ptr(ndr, "level2", r->level2);
18275                         ndr->depth++;
18276                         if (r->level2) {
18277                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18278                         }
18279                         ndr->depth--;
18280                 break;
18281
18282                 case 3:
18283                         ndr_print_ptr(ndr, "level3", r->level3);
18284                         ndr->depth++;
18285                         if (r->level3) {
18286                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18287                         }
18288                         ndr->depth--;
18289                 break;
18290
18291                 default:
18292                         ndr_print_bad_level(ndr, name, level);
18293         }
18294 }
18295
18296 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18297 {
18298         if (ndr_flags & NDR_SCALARS) {
18299                 NDR_CHECK(ndr_push_align(ndr, 4));
18300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18301                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18302                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18303         }
18304         if (ndr_flags & NDR_BUFFERS) {
18305                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18306         }
18307         return NDR_ERR_SUCCESS;
18308 }
18309
18310 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18311 {
18312         if (ndr_flags & NDR_SCALARS) {
18313                 NDR_CHECK(ndr_pull_align(ndr, 4));
18314                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18315                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18316                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18317         }
18318         if (ndr_flags & NDR_BUFFERS) {
18319                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18320         }
18321         return NDR_ERR_SUCCESS;
18322 }
18323
18324 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18325 {
18326         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18327         ndr->depth++;
18328         ndr_print_uint32(ndr, "level", r->level);
18329         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18330         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18331         ndr->depth--;
18332 }
18333
18334 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18335 {
18336         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18337         return NDR_ERR_SUCCESS;
18338 }
18339
18340 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18341 {
18342         uint32_t v;
18343         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18344         *r = v;
18345         return NDR_ERR_SUCCESS;
18346 }
18347
18348 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18349 {
18350         ndr_print_uint32(ndr, name, r);
18351         ndr->depth++;
18352         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18353         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18354         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18355         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18356         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18357         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18358         ndr->depth--;
18359 }
18360
18361 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PrinterEnumValues(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PrinterEnumValues *r)
18362 {
18363         uint32_t _save_relative_base_offset = ndr_push_get_relative_base_offset(ndr);
18364         if (ndr_flags & NDR_SCALARS) {
18365                 NDR_CHECK(ndr_push_align(ndr, 4));
18366                 NDR_CHECK(ndr_push_setup_relative_base_offset1(ndr, r, ndr->offset));
18367                 {
18368                         uint32_t _flags_save_string = ndr->flags;
18369                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18370                         NDR_CHECK(ndr_push_relative_ptr1(ndr, r->value_name));
18371                         ndr->flags = _flags_save_string;
18372                 }
18373                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2 * strlen_m_term(r->value_name)));
18374                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->type));
18375                 NDR_CHECK(ndr_push_relative_ptr1(ndr, r->data));
18376                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_size_spoolss_PrinterData(r->data, r->type, ndr->iconv_convenience, ndr->flags)));
18377         }
18378         if (ndr_flags & NDR_BUFFERS) {
18379                 NDR_CHECK(ndr_push_setup_relative_base_offset2(ndr, r));
18380                 {
18381                         uint32_t _flags_save_string = ndr->flags;
18382                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18383                         if (r->value_name) {
18384                                 NDR_CHECK(ndr_push_relative_ptr2(ndr, r->value_name));
18385                                 NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->value_name));
18386                         }
18387                         ndr->flags = _flags_save_string;
18388                 }
18389                 if (r->data) {
18390                         NDR_CHECK(ndr_push_relative_ptr2(ndr, r->data));
18391                         {
18392                                 struct ndr_push *_ndr_data;
18393                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18394                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_data, r->data, r->type));
18395                                 NDR_CHECK(ndr_push_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18396                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18397                         }
18398                 }
18399         }
18400         ndr_push_restore_relative_base_offset(ndr, _save_relative_base_offset);
18401         return NDR_ERR_SUCCESS;
18402 }
18403
18404 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PrinterEnumValues(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PrinterEnumValues *r)
18405 {
18406         uint32_t _save_relative_base_offset = ndr_pull_get_relative_base_offset(ndr);
18407         uint32_t _ptr_value_name;
18408         TALLOC_CTX *_mem_save_value_name_0;
18409         uint32_t _ptr_data;
18410         TALLOC_CTX *_mem_save_data_0;
18411         if (ndr_flags & NDR_SCALARS) {
18412                 NDR_CHECK(ndr_pull_align(ndr, 4));
18413                 NDR_CHECK(ndr_pull_setup_relative_base_offset1(ndr, r, ndr->offset));
18414                 {
18415                         uint32_t _flags_save_string = ndr->flags;
18416                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18417                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_value_name));
18418                         if (_ptr_value_name) {
18419                                 NDR_PULL_ALLOC(ndr, r->value_name);
18420                                 NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->value_name, _ptr_value_name));
18421                         } else {
18422                                 r->value_name = NULL;
18423                         }
18424                         ndr->flags = _flags_save_string;
18425                 }
18426                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->value_name_len));
18427                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->type));
18428                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data));
18429                 if (_ptr_data) {
18430                         NDR_PULL_ALLOC(ndr, r->data);
18431                         NDR_CHECK(ndr_pull_relative_ptr1(ndr, r->data, _ptr_data));
18432                 } else {
18433                         r->data = NULL;
18434                 }
18435                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->data_length));
18436         }
18437         if (ndr_flags & NDR_BUFFERS) {
18438                 NDR_CHECK(ndr_pull_setup_relative_base_offset2(ndr, r));
18439                 {
18440                         uint32_t _flags_save_string = ndr->flags;
18441                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18442                         if (r->value_name) {
18443                                 uint32_t _relative_save_offset;
18444                                 _relative_save_offset = ndr->offset;
18445                                 NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->value_name));
18446                                 _mem_save_value_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
18447                                 NDR_PULL_SET_MEM_CTX(ndr, r->value_name, 0);
18448                                 NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->value_name));
18449                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_name_0, 0);
18450                                 ndr->offset = _relative_save_offset;
18451                         }
18452                         ndr->flags = _flags_save_string;
18453                 }
18454                 if (r->data) {
18455                         uint32_t _relative_save_offset;
18456                         _relative_save_offset = ndr->offset;
18457                         NDR_CHECK(ndr_pull_relative_ptr2(ndr, r->data));
18458                         _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
18459                         NDR_PULL_SET_MEM_CTX(ndr, r->data, 0);
18460                         {
18461                                 struct ndr_pull *_ndr_data;
18462                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 0, r->data_length));
18463                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, r->data, r->type));
18464                                 NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, r->data));
18465                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 0, r->data_length));
18466                         }
18467                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, 0);
18468                         ndr->offset = _relative_save_offset;
18469                 }
18470         }
18471         ndr_pull_restore_relative_base_offset(ndr, _save_relative_base_offset);
18472         return NDR_ERR_SUCCESS;
18473 }
18474
18475 _PUBLIC_ void ndr_print_spoolss_PrinterEnumValues(struct ndr_print *ndr, const char *name, const struct spoolss_PrinterEnumValues *r)
18476 {
18477         ndr_print_struct(ndr, name, "spoolss_PrinterEnumValues");
18478         ndr->depth++;
18479         ndr_print_ptr(ndr, "value_name", r->value_name);
18480         ndr->depth++;
18481         if (r->value_name) {
18482                 ndr_print_string(ndr, "value_name", r->value_name);
18483         }
18484         ndr->depth--;
18485         ndr_print_uint32(ndr, "value_name_len", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2 * strlen_m_term(r->value_name):r->value_name_len);
18486         ndr_print_winreg_Type(ndr, "type", r->type);
18487         ndr_print_ptr(ndr, "data", r->data);
18488         ndr->depth++;
18489         if (r->data) {
18490                 ndr_print_set_switch_value(ndr, r->data, r->type);
18491                 ndr_print_spoolss_PrinterData(ndr, "data", r->data);
18492         }
18493         ndr->depth--;
18494         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);
18495         ndr->depth--;
18496 }
18497
18498 _PUBLIC_ size_t ndr_size_spoolss_PrinterEnumValues(const struct spoolss_PrinterEnumValues *r, struct smb_iconv_convenience *ic, int flags)
18499 {
18500         return ndr_size_struct(r, flags, (ndr_push_flags_fn_t)ndr_push_spoolss_PrinterEnumValues, ic);
18501 }
18502
18503 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18504 {
18505         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18506         return NDR_ERR_SUCCESS;
18507 }
18508
18509 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18510 {
18511         uint32_t v;
18512         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18513         *r = v;
18514         return NDR_ERR_SUCCESS;
18515 }
18516
18517 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18518 {
18519         ndr_print_uint32(ndr, name, r);
18520         ndr->depth++;
18521         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18522         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18523         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18524         ndr->depth--;
18525 }
18526
18527 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18528 {
18529         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18530         return NDR_ERR_SUCCESS;
18531 }
18532
18533 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18534 {
18535         uint32_t v;
18536         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18537         *r = v;
18538         return NDR_ERR_SUCCESS;
18539 }
18540
18541 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18542 {
18543         const char *val = NULL;
18544
18545         switch (r) {
18546                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18547                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18548         }
18549         ndr_print_enum(ndr, name, "ENUM", val, r);
18550 }
18551
18552 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18553 {
18554         if (ndr_flags & NDR_SCALARS) {
18555                 NDR_CHECK(ndr_push_align(ndr, 4));
18556                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18558                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18559                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18560                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18561                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18562                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18564                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18565                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18566                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18567                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18571         }
18572         if (ndr_flags & NDR_BUFFERS) {
18573         }
18574         return NDR_ERR_SUCCESS;
18575 }
18576
18577 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18578 {
18579         if (ndr_flags & NDR_SCALARS) {
18580                 NDR_CHECK(ndr_pull_align(ndr, 4));
18581                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18582                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18583                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18584                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18585                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18586                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18587                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18588                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18589                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18590                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18591                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18592                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18593                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18594                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18595                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18596         }
18597         if (ndr_flags & NDR_BUFFERS) {
18598         }
18599         return NDR_ERR_SUCCESS;
18600 }
18601
18602 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18603 {
18604         ndr_print_struct(ndr, name, "spoolss_PortData1");
18605         ndr->depth++;
18606         ndr_print_string(ndr, "portname", r->portname);
18607         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18608         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18609         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18610         ndr_print_uint32(ndr, "reserved", r->reserved);
18611         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18612         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18613         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18614         ndr_print_string(ndr, "queue", r->queue);
18615         ndr_print_string(ndr, "ip_address", r->ip_address);
18616         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18617         ndr_print_string(ndr, "device_type", r->device_type);
18618         ndr_print_uint32(ndr, "port_number", r->port_number);
18619         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18620         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18621         ndr->depth--;
18622 }
18623
18624 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18625 {
18626         if (ndr_flags & NDR_SCALARS) {
18627                 NDR_CHECK(ndr_push_align(ndr, 4));
18628                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18629                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18630                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18631                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18633                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18634                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18635                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18636                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18637                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18641                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18642         }
18643         if (ndr_flags & NDR_BUFFERS) {
18644         }
18645         return NDR_ERR_SUCCESS;
18646 }
18647
18648 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18649 {
18650         if (ndr_flags & NDR_SCALARS) {
18651                 NDR_CHECK(ndr_pull_align(ndr, 4));
18652                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18653                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18654                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18655                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18657                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18658                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18659                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18660                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18661                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18664                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18666         }
18667         if (ndr_flags & NDR_BUFFERS) {
18668         }
18669         return NDR_ERR_SUCCESS;
18670 }
18671
18672 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18673 {
18674         ndr_print_struct(ndr, name, "spoolss_PortData2");
18675         ndr->depth++;
18676         ndr_print_string(ndr, "portname", r->portname);
18677         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18678         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18679         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18680         ndr_print_uint32(ndr, "reserved", r->reserved);
18681         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18682         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18683         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18684         ndr_print_string(ndr, "queue", r->queue);
18685         ndr_print_string(ndr, "device_type", r->device_type);
18686         ndr_print_uint32(ndr, "port_number", r->port_number);
18687         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18688         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18689         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18690         ndr->depth--;
18691 }
18692
18693 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18694 {
18695         if (ndr_flags & NDR_SCALARS) {
18696                 NDR_CHECK(ndr_push_align(ndr, 4));
18697                 {
18698                         uint32_t _flags_save_string = ndr->flags;
18699                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18700                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18701                         ndr->flags = _flags_save_string;
18702                 }
18703         }
18704         if (ndr_flags & NDR_BUFFERS) {
18705         }
18706         return NDR_ERR_SUCCESS;
18707 }
18708
18709 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18710 {
18711         if (ndr_flags & NDR_SCALARS) {
18712                 NDR_CHECK(ndr_pull_align(ndr, 4));
18713                 {
18714                         uint32_t _flags_save_string = ndr->flags;
18715                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18716                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18717                         ndr->flags = _flags_save_string;
18718                 }
18719         }
18720         if (ndr_flags & NDR_BUFFERS) {
18721         }
18722         return NDR_ERR_SUCCESS;
18723 }
18724
18725 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18726 {
18727         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18728         ndr->depth++;
18729         ndr_print_string(ndr, "dll_name", r->dll_name);
18730         ndr->depth--;
18731 }
18732
18733 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18734 {
18735         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18736         return NDR_ERR_SUCCESS;
18737 }
18738
18739 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18740 {
18741         uint32_t v;
18742         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18743         *r = v;
18744         return NDR_ERR_SUCCESS;
18745 }
18746
18747 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18748 {
18749         ndr_print_uint32(ndr, name, r);
18750         ndr->depth++;
18751         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18752         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18753         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18754         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18755         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18756         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18757         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18758         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18759         ndr->depth--;
18760 }
18761
18762 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18763 {
18764         if (flags & NDR_IN) {
18765                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18766                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18767                 if (r->in.server) {
18768                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18769                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18770                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18771                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18772                 }
18773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18774                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18775                 if (r->in.buffer) {
18776                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18777                 }
18778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18779         }
18780         if (flags & NDR_OUT) {
18781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18782                 if (r->out.info) {
18783                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18784                 }
18785                 if (r->out.needed == NULL) {
18786                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18787                 }
18788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18789                 if (r->out.count == NULL) {
18790                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18791                 }
18792                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18793                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18794         }
18795         return NDR_ERR_SUCCESS;
18796 }
18797
18798 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18799 {
18800         uint32_t _ptr_server;
18801         uint32_t _ptr_buffer;
18802         uint32_t _ptr_info;
18803         TALLOC_CTX *_mem_save_server_0;
18804         TALLOC_CTX *_mem_save_buffer_0;
18805         TALLOC_CTX *_mem_save_info_0;
18806         TALLOC_CTX *_mem_save_needed_0;
18807         TALLOC_CTX *_mem_save_count_0;
18808         if (flags & NDR_IN) {
18809                 ZERO_STRUCT(r->out);
18810
18811                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18812                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18813                 if (_ptr_server) {
18814                         NDR_PULL_ALLOC(ndr, r->in.server);
18815                 } else {
18816                         r->in.server = NULL;
18817                 }
18818                 if (r->in.server) {
18819                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18820                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18821                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18822                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18823                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18824                                 return 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));
18825                         }
18826                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18827                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18828                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18829                 }
18830                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18831                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18832                 if (_ptr_buffer) {
18833                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18834                 } else {
18835                         r->in.buffer = NULL;
18836                 }
18837                 if (r->in.buffer) {
18838                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18839                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18840                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18841                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18842                 }
18843                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18844                 NDR_PULL_ALLOC(ndr, r->out.needed);
18845                 ZERO_STRUCTP(r->out.needed);
18846                 NDR_PULL_ALLOC(ndr, r->out.count);
18847                 ZERO_STRUCTP(r->out.count);
18848         }
18849         if (flags & NDR_OUT) {
18850                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18851                 if (_ptr_info) {
18852                         NDR_PULL_ALLOC(ndr, r->out.info);
18853                 } else {
18854                         r->out.info = NULL;
18855                 }
18856                 if (r->out.info) {
18857                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18858                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18859                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18860                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18861                 }
18862                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18863                         NDR_PULL_ALLOC(ndr, r->out.needed);
18864                 }
18865                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18866                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18867                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18868                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18869                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18870                         NDR_PULL_ALLOC(ndr, r->out.count);
18871                 }
18872                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18873                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18874                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18875                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18876                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18877         }
18878         return NDR_ERR_SUCCESS;
18879 }
18880
18881 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18882 {
18883         uint32_t cntr_info_0;
18884         if (flags & NDR_IN) {
18885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18887         }
18888         if (flags & NDR_OUT) {
18889                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18890                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18891                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18892                 }
18893                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18894                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18895                 }
18896         }
18897         return NDR_ERR_SUCCESS;
18898 }
18899
18900 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18901 {
18902         uint32_t cntr_info_0;
18903         TALLOC_CTX *_mem_save_info_0;
18904         if (flags & NDR_IN) {
18905                 ZERO_STRUCT(r->out);
18906
18907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18908                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18909         }
18910         if (flags & NDR_OUT) {
18911                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18912                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18913                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18914                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18915                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18916                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18917                 }
18918                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18919                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18920                 }
18921                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18922         }
18923         return NDR_ERR_SUCCESS;
18924 }
18925
18926 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18927 {
18928         uint32_t cntr_info_2;
18929         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18930         ndr->depth++;
18931         if (flags & NDR_SET_VALUES) {
18932                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18933         }
18934         if (flags & NDR_IN) {
18935                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18936                 ndr->depth++;
18937                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18938                 ndr_print_ptr(ndr, "server", r->in.server);
18939                 ndr->depth++;
18940                 if (r->in.server) {
18941                         ndr_print_string(ndr, "server", r->in.server);
18942                 }
18943                 ndr->depth--;
18944                 ndr_print_uint32(ndr, "level", r->in.level);
18945                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18946                 ndr->depth++;
18947                 if (r->in.buffer) {
18948                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18949                 }
18950                 ndr->depth--;
18951                 ndr_print_uint32(ndr, "offered", r->in.offered);
18952                 ndr->depth--;
18953         }
18954         if (flags & NDR_OUT) {
18955                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18956                 ndr->depth++;
18957                 ndr_print_ptr(ndr, "count", r->out.count);
18958                 ndr->depth++;
18959                 ndr_print_uint32(ndr, "count", *r->out.count);
18960                 ndr->depth--;
18961                 ndr_print_ptr(ndr, "info", r->out.info);
18962                 ndr->depth++;
18963                 ndr_print_ptr(ndr, "info", *r->out.info);
18964                 ndr->depth++;
18965                 if (*r->out.info) {
18966                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18967                         ndr->depth++;
18968                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18969                                 char *idx_2=NULL;
18970                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18971                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18972                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18973                                         free(idx_2);
18974                                 }
18975                         }
18976                         ndr->depth--;
18977                 }
18978                 ndr->depth--;
18979                 ndr->depth--;
18980                 ndr_print_ptr(ndr, "needed", r->out.needed);
18981                 ndr->depth++;
18982                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18983                 ndr->depth--;
18984                 ndr_print_WERROR(ndr, "result", r->out.result);
18985                 ndr->depth--;
18986         }
18987         ndr->depth--;
18988 }
18989
18990 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18991 {
18992         if (flags & NDR_IN) {
18993                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18994                 if (r->in.printername) {
18995                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18996                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18997                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18998                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18999                 }
19000                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
19001                 if (r->in.datatype) {
19002                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19003                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19004                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
19005                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19006                 }
19007                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19008                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
19009         }
19010         if (flags & NDR_OUT) {
19011                 if (r->out.handle == NULL) {
19012                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19013                 }
19014                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19015                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19016         }
19017         return NDR_ERR_SUCCESS;
19018 }
19019
19020 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
19021 {
19022         uint32_t _ptr_printername;
19023         uint32_t _ptr_datatype;
19024         TALLOC_CTX *_mem_save_printername_0;
19025         TALLOC_CTX *_mem_save_datatype_0;
19026         TALLOC_CTX *_mem_save_handle_0;
19027         if (flags & NDR_IN) {
19028                 ZERO_STRUCT(r->out);
19029
19030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
19031                 if (_ptr_printername) {
19032                         NDR_PULL_ALLOC(ndr, r->in.printername);
19033                 } else {
19034                         r->in.printername = NULL;
19035                 }
19036                 if (r->in.printername) {
19037                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19038                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
19039                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
19040                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
19041                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
19042                                 return 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));
19043                         }
19044                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
19045                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
19046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
19047                 }
19048                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
19049                 if (_ptr_datatype) {
19050                         NDR_PULL_ALLOC(ndr, r->in.datatype);
19051                 } else {
19052                         r->in.datatype = NULL;
19053                 }
19054                 if (r->in.datatype) {
19055                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
19056                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
19057                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
19058                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
19059                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
19060                                 return 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));
19061                         }
19062                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
19063                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
19064                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
19065                 }
19066                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
19067                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
19068                 NDR_PULL_ALLOC(ndr, r->out.handle);
19069                 ZERO_STRUCTP(r->out.handle);
19070         }
19071         if (flags & NDR_OUT) {
19072                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19073                         NDR_PULL_ALLOC(ndr, r->out.handle);
19074                 }
19075                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19076                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
19077                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
19078                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19079                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19080         }
19081         return NDR_ERR_SUCCESS;
19082 }
19083
19084 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
19085 {
19086         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
19087         ndr->depth++;
19088         if (flags & NDR_SET_VALUES) {
19089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19090         }
19091         if (flags & NDR_IN) {
19092                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
19093                 ndr->depth++;
19094                 ndr_print_ptr(ndr, "printername", r->in.printername);
19095                 ndr->depth++;
19096                 if (r->in.printername) {
19097                         ndr_print_string(ndr, "printername", r->in.printername);
19098                 }
19099                 ndr->depth--;
19100                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
19101                 ndr->depth++;
19102                 if (r->in.datatype) {
19103                         ndr_print_string(ndr, "datatype", r->in.datatype);
19104                 }
19105                 ndr->depth--;
19106                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
19107                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
19108                 ndr->depth--;
19109         }
19110         if (flags & NDR_OUT) {
19111                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
19112                 ndr->depth++;
19113                 ndr_print_ptr(ndr, "handle", r->out.handle);
19114                 ndr->depth++;
19115                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
19116                 ndr->depth--;
19117                 ndr_print_WERROR(ndr, "result", r->out.result);
19118                 ndr->depth--;
19119         }
19120         ndr->depth--;
19121 }
19122
19123 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
19124 {
19125         if (flags & NDR_IN) {
19126                 if (r->in.handle == NULL) {
19127                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19128                 }
19129                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19130                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19131                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
19132                 if (r->in.ctr) {
19133                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19134                 }
19135                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
19136         }
19137         if (flags & NDR_OUT) {
19138                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19139         }
19140         return NDR_ERR_SUCCESS;
19141 }
19142
19143 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
19144 {
19145         uint32_t _ptr_ctr;
19146         TALLOC_CTX *_mem_save_handle_0;
19147         TALLOC_CTX *_mem_save_ctr_0;
19148         if (flags & NDR_IN) {
19149                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19150                         NDR_PULL_ALLOC(ndr, r->in.handle);
19151                 }
19152                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19153                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19154                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19155                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19157                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
19158                 if (_ptr_ctr) {
19159                         NDR_PULL_ALLOC(ndr, r->in.ctr);
19160                 } else {
19161                         r->in.ctr = NULL;
19162                 }
19163                 if (r->in.ctr) {
19164                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19165                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
19166                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
19167                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
19168                 }
19169                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
19170         }
19171         if (flags & NDR_OUT) {
19172                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19173         }
19174         return NDR_ERR_SUCCESS;
19175 }
19176
19177 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
19178 {
19179         ndr_print_struct(ndr, name, "spoolss_SetJob");
19180         ndr->depth++;
19181         if (flags & NDR_SET_VALUES) {
19182                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19183         }
19184         if (flags & NDR_IN) {
19185                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
19186                 ndr->depth++;
19187                 ndr_print_ptr(ndr, "handle", r->in.handle);
19188                 ndr->depth++;
19189                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19190                 ndr->depth--;
19191                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19192                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
19193                 ndr->depth++;
19194                 if (r->in.ctr) {
19195                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
19196                 }
19197                 ndr->depth--;
19198                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
19199                 ndr->depth--;
19200         }
19201         if (flags & NDR_OUT) {
19202                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
19203                 ndr->depth++;
19204                 ndr_print_WERROR(ndr, "result", r->out.result);
19205                 ndr->depth--;
19206         }
19207         ndr->depth--;
19208 }
19209
19210 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
19211 {
19212         if (flags & NDR_IN) {
19213                 if (r->in.handle == NULL) {
19214                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19215                 }
19216                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19217                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
19218                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19219                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19220                 if (r->in.buffer) {
19221                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19222                 }
19223                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19224         }
19225         if (flags & NDR_OUT) {
19226                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19227                 if (r->out.info) {
19228                         {
19229                                 struct ndr_push *_ndr_info;
19230                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19231                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19232                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19233                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19234                         }
19235                 }
19236                 if (r->out.needed == NULL) {
19237                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19238                 }
19239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19240                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19241         }
19242         return NDR_ERR_SUCCESS;
19243 }
19244
19245 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
19246 {
19247         uint32_t _ptr_buffer;
19248         uint32_t _ptr_info;
19249         TALLOC_CTX *_mem_save_handle_0;
19250         TALLOC_CTX *_mem_save_buffer_0;
19251         TALLOC_CTX *_mem_save_info_0;
19252         TALLOC_CTX *_mem_save_needed_0;
19253         if (flags & NDR_IN) {
19254                 ZERO_STRUCT(r->out);
19255
19256                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19257                         NDR_PULL_ALLOC(ndr, r->in.handle);
19258                 }
19259                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19260                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19261                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19262                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19263                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
19264                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19265                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19266                 if (_ptr_buffer) {
19267                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19268                 } else {
19269                         r->in.buffer = NULL;
19270                 }
19271                 if (r->in.buffer) {
19272                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19273                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19274                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19275                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19276                 }
19277                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19278                 NDR_PULL_ALLOC(ndr, r->out.needed);
19279                 ZERO_STRUCTP(r->out.needed);
19280         }
19281         if (flags & NDR_OUT) {
19282                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19283                 if (_ptr_info) {
19284                         NDR_PULL_ALLOC(ndr, r->out.info);
19285                 } else {
19286                         r->out.info = NULL;
19287                 }
19288                 if (r->out.info) {
19289                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19290                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19291                         {
19292                                 struct ndr_pull *_ndr_info;
19293                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19294                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19295                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19296                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19297                         }
19298                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19299                 }
19300                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19301                         NDR_PULL_ALLOC(ndr, r->out.needed);
19302                 }
19303                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19304                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19305                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19306                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19307                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19308         }
19309         return NDR_ERR_SUCCESS;
19310 }
19311
19312 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19313 {
19314         ndr_print_struct(ndr, name, "spoolss_GetJob");
19315         ndr->depth++;
19316         if (flags & NDR_SET_VALUES) {
19317                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19318         }
19319         if (flags & NDR_IN) {
19320                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19321                 ndr->depth++;
19322                 ndr_print_ptr(ndr, "handle", r->in.handle);
19323                 ndr->depth++;
19324                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19325                 ndr->depth--;
19326                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19327                 ndr_print_uint32(ndr, "level", r->in.level);
19328                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19329                 ndr->depth++;
19330                 if (r->in.buffer) {
19331                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19332                 }
19333                 ndr->depth--;
19334                 ndr_print_uint32(ndr, "offered", r->in.offered);
19335                 ndr->depth--;
19336         }
19337         if (flags & NDR_OUT) {
19338                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19339                 ndr->depth++;
19340                 ndr_print_ptr(ndr, "info", r->out.info);
19341                 ndr->depth++;
19342                 if (r->out.info) {
19343                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19344                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19345                 }
19346                 ndr->depth--;
19347                 ndr_print_ptr(ndr, "needed", r->out.needed);
19348                 ndr->depth++;
19349                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19350                 ndr->depth--;
19351                 ndr_print_WERROR(ndr, "result", r->out.result);
19352                 ndr->depth--;
19353         }
19354         ndr->depth--;
19355 }
19356
19357 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19358 {
19359         if (flags & NDR_IN) {
19360                 if (r->in.handle == NULL) {
19361                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19362                 }
19363                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19364                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19365                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19367                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19368                 if (r->in.buffer) {
19369                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19370                 }
19371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19372         }
19373         if (flags & NDR_OUT) {
19374                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19375                 if (r->out.info) {
19376                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19377                 }
19378                 if (r->out.needed == NULL) {
19379                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19380                 }
19381                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19382                 if (r->out.count == NULL) {
19383                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19384                 }
19385                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19386                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19387         }
19388         return NDR_ERR_SUCCESS;
19389 }
19390
19391 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19392 {
19393         uint32_t _ptr_buffer;
19394         uint32_t _ptr_info;
19395         TALLOC_CTX *_mem_save_handle_0;
19396         TALLOC_CTX *_mem_save_buffer_0;
19397         TALLOC_CTX *_mem_save_info_0;
19398         TALLOC_CTX *_mem_save_needed_0;
19399         TALLOC_CTX *_mem_save_count_0;
19400         if (flags & NDR_IN) {
19401                 ZERO_STRUCT(r->out);
19402
19403                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19404                         NDR_PULL_ALLOC(ndr, r->in.handle);
19405                 }
19406                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19407                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19408                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19409                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19411                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19412                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19413                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19414                 if (_ptr_buffer) {
19415                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19416                 } else {
19417                         r->in.buffer = NULL;
19418                 }
19419                 if (r->in.buffer) {
19420                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19421                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19422                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19423                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19424                 }
19425                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19426                 NDR_PULL_ALLOC(ndr, r->out.needed);
19427                 ZERO_STRUCTP(r->out.needed);
19428                 NDR_PULL_ALLOC(ndr, r->out.count);
19429                 ZERO_STRUCTP(r->out.count);
19430         }
19431         if (flags & NDR_OUT) {
19432                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19433                 if (_ptr_info) {
19434                         NDR_PULL_ALLOC(ndr, r->out.info);
19435                 } else {
19436                         r->out.info = NULL;
19437                 }
19438                 if (r->out.info) {
19439                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19440                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19441                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19442                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19443                 }
19444                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19445                         NDR_PULL_ALLOC(ndr, r->out.needed);
19446                 }
19447                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19448                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19449                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19450                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19451                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19452                         NDR_PULL_ALLOC(ndr, r->out.count);
19453                 }
19454                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19455                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19457                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19458                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19459         }
19460         return NDR_ERR_SUCCESS;
19461 }
19462
19463 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19464 {
19465         uint32_t cntr_info_0;
19466         if (flags & NDR_IN) {
19467                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19468                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19469         }
19470         if (flags & NDR_OUT) {
19471                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19472                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19473                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19474                 }
19475                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19476                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19477                 }
19478         }
19479         return NDR_ERR_SUCCESS;
19480 }
19481
19482 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19483 {
19484         uint32_t cntr_info_0;
19485         TALLOC_CTX *_mem_save_info_0;
19486         if (flags & NDR_IN) {
19487                 ZERO_STRUCT(r->out);
19488
19489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19490                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19491         }
19492         if (flags & NDR_OUT) {
19493                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19494                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19495                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19496                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19497                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19498                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19499                 }
19500                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19501                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19502                 }
19503                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19504         }
19505         return NDR_ERR_SUCCESS;
19506 }
19507
19508 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19509 {
19510         uint32_t cntr_info_2;
19511         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19512         ndr->depth++;
19513         if (flags & NDR_SET_VALUES) {
19514                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19515         }
19516         if (flags & NDR_IN) {
19517                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19518                 ndr->depth++;
19519                 ndr_print_ptr(ndr, "handle", r->in.handle);
19520                 ndr->depth++;
19521                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19522                 ndr->depth--;
19523                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19524                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19525                 ndr_print_uint32(ndr, "level", r->in.level);
19526                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19527                 ndr->depth++;
19528                 if (r->in.buffer) {
19529                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19530                 }
19531                 ndr->depth--;
19532                 ndr_print_uint32(ndr, "offered", r->in.offered);
19533                 ndr->depth--;
19534         }
19535         if (flags & NDR_OUT) {
19536                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19537                 ndr->depth++;
19538                 ndr_print_ptr(ndr, "count", r->out.count);
19539                 ndr->depth++;
19540                 ndr_print_uint32(ndr, "count", *r->out.count);
19541                 ndr->depth--;
19542                 ndr_print_ptr(ndr, "info", r->out.info);
19543                 ndr->depth++;
19544                 ndr_print_ptr(ndr, "info", *r->out.info);
19545                 ndr->depth++;
19546                 if (*r->out.info) {
19547                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19548                         ndr->depth++;
19549                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19550                                 char *idx_2=NULL;
19551                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19552                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19553                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19554                                         free(idx_2);
19555                                 }
19556                         }
19557                         ndr->depth--;
19558                 }
19559                 ndr->depth--;
19560                 ndr->depth--;
19561                 ndr_print_ptr(ndr, "needed", r->out.needed);
19562                 ndr->depth++;
19563                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19564                 ndr->depth--;
19565                 ndr_print_WERROR(ndr, "result", r->out.result);
19566                 ndr->depth--;
19567         }
19568         ndr->depth--;
19569 }
19570
19571 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19572 {
19573         if (flags & NDR_IN) {
19574         }
19575         if (flags & NDR_OUT) {
19576                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19577         }
19578         return NDR_ERR_SUCCESS;
19579 }
19580
19581 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19582 {
19583         if (flags & NDR_IN) {
19584         }
19585         if (flags & NDR_OUT) {
19586                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19587         }
19588         return NDR_ERR_SUCCESS;
19589 }
19590
19591 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19592 {
19593         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19594         ndr->depth++;
19595         if (flags & NDR_SET_VALUES) {
19596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19597         }
19598         if (flags & NDR_IN) {
19599                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19600                 ndr->depth++;
19601                 ndr->depth--;
19602         }
19603         if (flags & NDR_OUT) {
19604                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19605                 ndr->depth++;
19606                 ndr_print_WERROR(ndr, "result", r->out.result);
19607                 ndr->depth--;
19608         }
19609         ndr->depth--;
19610 }
19611
19612 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19613 {
19614         if (flags & NDR_IN) {
19615                 if (r->in.handle == NULL) {
19616                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19617                 }
19618                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19619         }
19620         if (flags & NDR_OUT) {
19621                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19622         }
19623         return NDR_ERR_SUCCESS;
19624 }
19625
19626 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19627 {
19628         TALLOC_CTX *_mem_save_handle_0;
19629         if (flags & NDR_IN) {
19630                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19631                         NDR_PULL_ALLOC(ndr, r->in.handle);
19632                 }
19633                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19634                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19635                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19636                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19637         }
19638         if (flags & NDR_OUT) {
19639                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19640         }
19641         return NDR_ERR_SUCCESS;
19642 }
19643
19644 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19645 {
19646         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19647         ndr->depth++;
19648         if (flags & NDR_SET_VALUES) {
19649                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19650         }
19651         if (flags & NDR_IN) {
19652                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19653                 ndr->depth++;
19654                 ndr_print_ptr(ndr, "handle", r->in.handle);
19655                 ndr->depth++;
19656                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19657                 ndr->depth--;
19658                 ndr->depth--;
19659         }
19660         if (flags & NDR_OUT) {
19661                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19662                 ndr->depth++;
19663                 ndr_print_WERROR(ndr, "result", r->out.result);
19664                 ndr->depth--;
19665         }
19666         ndr->depth--;
19667 }
19668
19669 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19670 {
19671         if (flags & NDR_IN) {
19672                 if (r->in.handle == NULL) {
19673                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19674                 }
19675                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19676                 if (r->in.info_ctr == NULL) {
19677                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19678                 }
19679                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19680                 if (r->in.devmode_ctr == NULL) {
19681                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19682                 }
19683                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19684                 if (r->in.secdesc_ctr == NULL) {
19685                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19686                 }
19687                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19688                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19689         }
19690         if (flags & NDR_OUT) {
19691                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19692         }
19693         return NDR_ERR_SUCCESS;
19694 }
19695
19696 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19697 {
19698         TALLOC_CTX *_mem_save_handle_0;
19699         TALLOC_CTX *_mem_save_info_ctr_0;
19700         TALLOC_CTX *_mem_save_devmode_ctr_0;
19701         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19702         if (flags & NDR_IN) {
19703                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19704                         NDR_PULL_ALLOC(ndr, r->in.handle);
19705                 }
19706                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19707                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19708                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19709                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19710                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19711                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19712                 }
19713                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19714                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19715                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19716                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19717                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19718                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19719                 }
19720                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19721                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19722                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19723                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19724                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19725                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19726                 }
19727                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19728                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19729                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19730                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19731                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19732         }
19733         if (flags & NDR_OUT) {
19734                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19735         }
19736         return NDR_ERR_SUCCESS;
19737 }
19738
19739 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19740 {
19741         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19742         ndr->depth++;
19743         if (flags & NDR_SET_VALUES) {
19744                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19745         }
19746         if (flags & NDR_IN) {
19747                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19748                 ndr->depth++;
19749                 ndr_print_ptr(ndr, "handle", r->in.handle);
19750                 ndr->depth++;
19751                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19752                 ndr->depth--;
19753                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19754                 ndr->depth++;
19755                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19756                 ndr->depth--;
19757                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19758                 ndr->depth++;
19759                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19760                 ndr->depth--;
19761                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19762                 ndr->depth++;
19763                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19764                 ndr->depth--;
19765                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19766                 ndr->depth--;
19767         }
19768         if (flags & NDR_OUT) {
19769                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19770                 ndr->depth++;
19771                 ndr_print_WERROR(ndr, "result", r->out.result);
19772                 ndr->depth--;
19773         }
19774         ndr->depth--;
19775 }
19776
19777 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19778 {
19779         if (flags & NDR_IN) {
19780                 if (r->in.handle == NULL) {
19781                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19782                 }
19783                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19784                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19785                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19786                 if (r->in.buffer) {
19787                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19788                 }
19789                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19790         }
19791         if (flags & NDR_OUT) {
19792                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19793                 if (r->out.info) {
19794                         {
19795                                 struct ndr_push *_ndr_info;
19796                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19797                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19798                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19799                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19800                         }
19801                 }
19802                 if (r->out.needed == NULL) {
19803                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19804                 }
19805                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19806                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19807         }
19808         return NDR_ERR_SUCCESS;
19809 }
19810
19811 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19812 {
19813         uint32_t _ptr_buffer;
19814         uint32_t _ptr_info;
19815         TALLOC_CTX *_mem_save_handle_0;
19816         TALLOC_CTX *_mem_save_buffer_0;
19817         TALLOC_CTX *_mem_save_info_0;
19818         TALLOC_CTX *_mem_save_needed_0;
19819         if (flags & NDR_IN) {
19820                 ZERO_STRUCT(r->out);
19821
19822                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19823                         NDR_PULL_ALLOC(ndr, r->in.handle);
19824                 }
19825                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19826                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19827                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19828                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19829                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19830                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19831                 if (_ptr_buffer) {
19832                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19833                 } else {
19834                         r->in.buffer = NULL;
19835                 }
19836                 if (r->in.buffer) {
19837                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19838                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19839                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19840                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19841                 }
19842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19843                 NDR_PULL_ALLOC(ndr, r->out.needed);
19844                 ZERO_STRUCTP(r->out.needed);
19845         }
19846         if (flags & NDR_OUT) {
19847                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19848                 if (_ptr_info) {
19849                         NDR_PULL_ALLOC(ndr, r->out.info);
19850                 } else {
19851                         r->out.info = NULL;
19852                 }
19853                 if (r->out.info) {
19854                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19855                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19856                         {
19857                                 struct ndr_pull *_ndr_info;
19858                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19859                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19860                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19861                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19862                         }
19863                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19864                 }
19865                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19866                         NDR_PULL_ALLOC(ndr, r->out.needed);
19867                 }
19868                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19869                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19870                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19871                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19872                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19873         }
19874         return NDR_ERR_SUCCESS;
19875 }
19876
19877 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19878 {
19879         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19880         ndr->depth++;
19881         if (flags & NDR_SET_VALUES) {
19882                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19883         }
19884         if (flags & NDR_IN) {
19885                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19886                 ndr->depth++;
19887                 ndr_print_ptr(ndr, "handle", r->in.handle);
19888                 ndr->depth++;
19889                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19890                 ndr->depth--;
19891                 ndr_print_uint32(ndr, "level", r->in.level);
19892                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19893                 ndr->depth++;
19894                 if (r->in.buffer) {
19895                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19896                 }
19897                 ndr->depth--;
19898                 ndr_print_uint32(ndr, "offered", r->in.offered);
19899                 ndr->depth--;
19900         }
19901         if (flags & NDR_OUT) {
19902                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19903                 ndr->depth++;
19904                 ndr_print_ptr(ndr, "info", r->out.info);
19905                 ndr->depth++;
19906                 if (r->out.info) {
19907                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19908                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19909                 }
19910                 ndr->depth--;
19911                 ndr_print_ptr(ndr, "needed", r->out.needed);
19912                 ndr->depth++;
19913                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19914                 ndr->depth--;
19915                 ndr_print_WERROR(ndr, "result", r->out.result);
19916                 ndr->depth--;
19917         }
19918         ndr->depth--;
19919 }
19920
19921 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19922 {
19923         if (flags & NDR_IN) {
19924                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19925                 if (r->in.servername) {
19926                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19927                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19928                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19929                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19930                 }
19931                 if (r->in.info_ctr == NULL) {
19932                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19933                 }
19934                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19935         }
19936         if (flags & NDR_OUT) {
19937                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19938         }
19939         return NDR_ERR_SUCCESS;
19940 }
19941
19942 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19943 {
19944         uint32_t _ptr_servername;
19945         TALLOC_CTX *_mem_save_servername_0;
19946         TALLOC_CTX *_mem_save_info_ctr_0;
19947         if (flags & NDR_IN) {
19948                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19949                 if (_ptr_servername) {
19950                         NDR_PULL_ALLOC(ndr, r->in.servername);
19951                 } else {
19952                         r->in.servername = NULL;
19953                 }
19954                 if (r->in.servername) {
19955                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19956                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19959                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19960                                 return 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));
19961                         }
19962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19965                 }
19966                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19967                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19968                 }
19969                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19970                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19971                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19972                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19973         }
19974         if (flags & NDR_OUT) {
19975                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19976         }
19977         return NDR_ERR_SUCCESS;
19978 }
19979
19980 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19981 {
19982         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19983         ndr->depth++;
19984         if (flags & NDR_SET_VALUES) {
19985                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19986         }
19987         if (flags & NDR_IN) {
19988                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19989                 ndr->depth++;
19990                 ndr_print_ptr(ndr, "servername", r->in.servername);
19991                 ndr->depth++;
19992                 if (r->in.servername) {
19993                         ndr_print_string(ndr, "servername", r->in.servername);
19994                 }
19995                 ndr->depth--;
19996                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19997                 ndr->depth++;
19998                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19999                 ndr->depth--;
20000                 ndr->depth--;
20001         }
20002         if (flags & NDR_OUT) {
20003                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
20004                 ndr->depth++;
20005                 ndr_print_WERROR(ndr, "result", r->out.result);
20006                 ndr->depth--;
20007         }
20008         ndr->depth--;
20009 }
20010
20011 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
20012 {
20013         if (flags & NDR_IN) {
20014                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20015                 if (r->in.server) {
20016                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20017                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20018                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20019                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20020                 }
20021                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20022                 if (r->in.environment) {
20023                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20024                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20025                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20026                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20027                 }
20028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20029                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20030                 if (r->in.buffer) {
20031                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20032                 }
20033                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20034         }
20035         if (flags & NDR_OUT) {
20036                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20037                 if (r->out.info) {
20038                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20039                 }
20040                 if (r->out.needed == NULL) {
20041                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20042                 }
20043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20044                 if (r->out.count == NULL) {
20045                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20046                 }
20047                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20048                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20049         }
20050         return NDR_ERR_SUCCESS;
20051 }
20052
20053 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
20054 {
20055         uint32_t _ptr_server;
20056         uint32_t _ptr_environment;
20057         uint32_t _ptr_buffer;
20058         uint32_t _ptr_info;
20059         TALLOC_CTX *_mem_save_server_0;
20060         TALLOC_CTX *_mem_save_environment_0;
20061         TALLOC_CTX *_mem_save_buffer_0;
20062         TALLOC_CTX *_mem_save_info_0;
20063         TALLOC_CTX *_mem_save_needed_0;
20064         TALLOC_CTX *_mem_save_count_0;
20065         if (flags & NDR_IN) {
20066                 ZERO_STRUCT(r->out);
20067
20068                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20069                 if (_ptr_server) {
20070                         NDR_PULL_ALLOC(ndr, r->in.server);
20071                 } else {
20072                         r->in.server = NULL;
20073                 }
20074                 if (r->in.server) {
20075                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20076                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20077                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20078                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20079                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20080                                 return 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));
20081                         }
20082                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20083                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20084                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20085                 }
20086                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20087                 if (_ptr_environment) {
20088                         NDR_PULL_ALLOC(ndr, r->in.environment);
20089                 } else {
20090                         r->in.environment = NULL;
20091                 }
20092                 if (r->in.environment) {
20093                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20094                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20095                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20096                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20097                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20098                                 return 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));
20099                         }
20100                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20101                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20102                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20103                 }
20104                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20105                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20106                 if (_ptr_buffer) {
20107                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20108                 } else {
20109                         r->in.buffer = NULL;
20110                 }
20111                 if (r->in.buffer) {
20112                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20113                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20114                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20116                 }
20117                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20118                 NDR_PULL_ALLOC(ndr, r->out.needed);
20119                 ZERO_STRUCTP(r->out.needed);
20120                 NDR_PULL_ALLOC(ndr, r->out.count);
20121                 ZERO_STRUCTP(r->out.count);
20122         }
20123         if (flags & NDR_OUT) {
20124                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20125                 if (_ptr_info) {
20126                         NDR_PULL_ALLOC(ndr, r->out.info);
20127                 } else {
20128                         r->out.info = NULL;
20129                 }
20130                 if (r->out.info) {
20131                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20132                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20133                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20134                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20135                 }
20136                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20137                         NDR_PULL_ALLOC(ndr, r->out.needed);
20138                 }
20139                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20140                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20143                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20144                         NDR_PULL_ALLOC(ndr, r->out.count);
20145                 }
20146                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20147                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20149                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20150                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20151         }
20152         return NDR_ERR_SUCCESS;
20153 }
20154
20155 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
20156 {
20157         uint32_t cntr_info_0;
20158         if (flags & NDR_IN) {
20159                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20161         }
20162         if (flags & NDR_OUT) {
20163                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20164                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20165                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20166                 }
20167                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20168                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20169                 }
20170         }
20171         return NDR_ERR_SUCCESS;
20172 }
20173
20174 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
20175 {
20176         uint32_t cntr_info_0;
20177         TALLOC_CTX *_mem_save_info_0;
20178         if (flags & NDR_IN) {
20179                 ZERO_STRUCT(r->out);
20180
20181                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20182                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20183         }
20184         if (flags & NDR_OUT) {
20185                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20186                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20187                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20188                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20189                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20190                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20191                 }
20192                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20193                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20194                 }
20195                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20196         }
20197         return NDR_ERR_SUCCESS;
20198 }
20199
20200 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
20201 {
20202         uint32_t cntr_info_2;
20203         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
20204         ndr->depth++;
20205         if (flags & NDR_SET_VALUES) {
20206                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20207         }
20208         if (flags & NDR_IN) {
20209                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
20210                 ndr->depth++;
20211                 ndr_print_ptr(ndr, "server", r->in.server);
20212                 ndr->depth++;
20213                 if (r->in.server) {
20214                         ndr_print_string(ndr, "server", r->in.server);
20215                 }
20216                 ndr->depth--;
20217                 ndr_print_ptr(ndr, "environment", r->in.environment);
20218                 ndr->depth++;
20219                 if (r->in.environment) {
20220                         ndr_print_string(ndr, "environment", r->in.environment);
20221                 }
20222                 ndr->depth--;
20223                 ndr_print_uint32(ndr, "level", r->in.level);
20224                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20225                 ndr->depth++;
20226                 if (r->in.buffer) {
20227                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20228                 }
20229                 ndr->depth--;
20230                 ndr_print_uint32(ndr, "offered", r->in.offered);
20231                 ndr->depth--;
20232         }
20233         if (flags & NDR_OUT) {
20234                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
20235                 ndr->depth++;
20236                 ndr_print_ptr(ndr, "count", r->out.count);
20237                 ndr->depth++;
20238                 ndr_print_uint32(ndr, "count", *r->out.count);
20239                 ndr->depth--;
20240                 ndr_print_ptr(ndr, "info", r->out.info);
20241                 ndr->depth++;
20242                 ndr_print_ptr(ndr, "info", *r->out.info);
20243                 ndr->depth++;
20244                 if (*r->out.info) {
20245                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20246                         ndr->depth++;
20247                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20248                                 char *idx_2=NULL;
20249                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20250                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20251                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20252                                         free(idx_2);
20253                                 }
20254                         }
20255                         ndr->depth--;
20256                 }
20257                 ndr->depth--;
20258                 ndr->depth--;
20259                 ndr_print_ptr(ndr, "needed", r->out.needed);
20260                 ndr->depth++;
20261                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20262                 ndr->depth--;
20263                 ndr_print_WERROR(ndr, "result", r->out.result);
20264                 ndr->depth--;
20265         }
20266         ndr->depth--;
20267 }
20268
20269 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20270 {
20271         if (flags & NDR_IN) {
20272         }
20273         if (flags & NDR_OUT) {
20274                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20275         }
20276         return NDR_ERR_SUCCESS;
20277 }
20278
20279 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20280 {
20281         if (flags & NDR_IN) {
20282         }
20283         if (flags & NDR_OUT) {
20284                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20285         }
20286         return NDR_ERR_SUCCESS;
20287 }
20288
20289 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20290 {
20291         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
20292         ndr->depth++;
20293         if (flags & NDR_SET_VALUES) {
20294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20295         }
20296         if (flags & NDR_IN) {
20297                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20298                 ndr->depth++;
20299                 ndr->depth--;
20300         }
20301         if (flags & NDR_OUT) {
20302                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20303                 ndr->depth++;
20304                 ndr_print_WERROR(ndr, "result", r->out.result);
20305                 ndr->depth--;
20306         }
20307         ndr->depth--;
20308 }
20309
20310 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20311 {
20312         if (flags & NDR_IN) {
20313                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20314                 if (r->in.server) {
20315                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20316                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20317                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20318                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20319                 }
20320                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20321                 if (r->in.environment) {
20322                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20323                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20325                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20326                 }
20327                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20328                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20329                 if (r->in.buffer) {
20330                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20331                 }
20332                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20333         }
20334         if (flags & NDR_OUT) {
20335                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20336                 if (r->out.info) {
20337                         {
20338                                 struct ndr_push *_ndr_info;
20339                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20340                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20341                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20342                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20343                         }
20344                 }
20345                 if (r->out.needed == NULL) {
20346                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20347                 }
20348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20349                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20350         }
20351         return NDR_ERR_SUCCESS;
20352 }
20353
20354 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20355 {
20356         uint32_t _ptr_server;
20357         uint32_t _ptr_environment;
20358         uint32_t _ptr_buffer;
20359         uint32_t _ptr_info;
20360         TALLOC_CTX *_mem_save_server_0;
20361         TALLOC_CTX *_mem_save_environment_0;
20362         TALLOC_CTX *_mem_save_buffer_0;
20363         TALLOC_CTX *_mem_save_info_0;
20364         TALLOC_CTX *_mem_save_needed_0;
20365         if (flags & NDR_IN) {
20366                 ZERO_STRUCT(r->out);
20367
20368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20369                 if (_ptr_server) {
20370                         NDR_PULL_ALLOC(ndr, r->in.server);
20371                 } else {
20372                         r->in.server = NULL;
20373                 }
20374                 if (r->in.server) {
20375                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20376                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20377                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20378                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20379                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20380                                 return 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));
20381                         }
20382                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20383                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20384                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20385                 }
20386                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20387                 if (_ptr_environment) {
20388                         NDR_PULL_ALLOC(ndr, r->in.environment);
20389                 } else {
20390                         r->in.environment = NULL;
20391                 }
20392                 if (r->in.environment) {
20393                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20394                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20395                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20396                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20397                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20398                                 return 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));
20399                         }
20400                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20401                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20402                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20403                 }
20404                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20405                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20406                 if (_ptr_buffer) {
20407                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20408                 } else {
20409                         r->in.buffer = NULL;
20410                 }
20411                 if (r->in.buffer) {
20412                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20413                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20414                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20415                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20416                 }
20417                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20418                 NDR_PULL_ALLOC(ndr, r->out.needed);
20419                 ZERO_STRUCTP(r->out.needed);
20420         }
20421         if (flags & NDR_OUT) {
20422                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20423                 if (_ptr_info) {
20424                         NDR_PULL_ALLOC(ndr, r->out.info);
20425                 } else {
20426                         r->out.info = NULL;
20427                 }
20428                 if (r->out.info) {
20429                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20430                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20431                         {
20432                                 struct ndr_pull *_ndr_info;
20433                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20434                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20435                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20436                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20437                         }
20438                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20439                 }
20440                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20441                         NDR_PULL_ALLOC(ndr, r->out.needed);
20442                 }
20443                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20444                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20445                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20446                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20447                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20448         }
20449         return NDR_ERR_SUCCESS;
20450 }
20451
20452 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20453 {
20454         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20455         ndr->depth++;
20456         if (flags & NDR_SET_VALUES) {
20457                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20458         }
20459         if (flags & NDR_IN) {
20460                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20461                 ndr->depth++;
20462                 ndr_print_ptr(ndr, "server", r->in.server);
20463                 ndr->depth++;
20464                 if (r->in.server) {
20465                         ndr_print_string(ndr, "server", r->in.server);
20466                 }
20467                 ndr->depth--;
20468                 ndr_print_ptr(ndr, "environment", r->in.environment);
20469                 ndr->depth++;
20470                 if (r->in.environment) {
20471                         ndr_print_string(ndr, "environment", r->in.environment);
20472                 }
20473                 ndr->depth--;
20474                 ndr_print_uint32(ndr, "level", r->in.level);
20475                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20476                 ndr->depth++;
20477                 if (r->in.buffer) {
20478                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20479                 }
20480                 ndr->depth--;
20481                 ndr_print_uint32(ndr, "offered", r->in.offered);
20482                 ndr->depth--;
20483         }
20484         if (flags & NDR_OUT) {
20485                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20486                 ndr->depth++;
20487                 ndr_print_ptr(ndr, "info", r->out.info);
20488                 ndr->depth++;
20489                 if (r->out.info) {
20490                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20491                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20492                 }
20493                 ndr->depth--;
20494                 ndr_print_ptr(ndr, "needed", r->out.needed);
20495                 ndr->depth++;
20496                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20497                 ndr->depth--;
20498                 ndr_print_WERROR(ndr, "result", r->out.result);
20499                 ndr->depth--;
20500         }
20501         ndr->depth--;
20502 }
20503
20504 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20505 {
20506         if (flags & NDR_IN) {
20507                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20508                 if (r->in.server) {
20509                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20510                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20511                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20512                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20513                 }
20514                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20516                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20517                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20518                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20521                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20522         }
20523         if (flags & NDR_OUT) {
20524                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20525         }
20526         return NDR_ERR_SUCCESS;
20527 }
20528
20529 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20530 {
20531         uint32_t _ptr_server;
20532         TALLOC_CTX *_mem_save_server_0;
20533         if (flags & NDR_IN) {
20534                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20535                 if (_ptr_server) {
20536                         NDR_PULL_ALLOC(ndr, r->in.server);
20537                 } else {
20538                         r->in.server = NULL;
20539                 }
20540                 if (r->in.server) {
20541                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20542                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20543                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20544                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20545                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20546                                 return 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));
20547                         }
20548                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20549                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20550                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20551                 }
20552                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20553                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20554                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20555                         return 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));
20556                 }
20557                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20558                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20559                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20560                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20561                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20562                         return 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));
20563                 }
20564                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20565                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20566         }
20567         if (flags & NDR_OUT) {
20568                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20569         }
20570         return NDR_ERR_SUCCESS;
20571 }
20572
20573 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20574 {
20575         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20576         ndr->depth++;
20577         if (flags & NDR_SET_VALUES) {
20578                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20579         }
20580         if (flags & NDR_IN) {
20581                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20582                 ndr->depth++;
20583                 ndr_print_ptr(ndr, "server", r->in.server);
20584                 ndr->depth++;
20585                 if (r->in.server) {
20586                         ndr_print_string(ndr, "server", r->in.server);
20587                 }
20588                 ndr->depth--;
20589                 ndr_print_string(ndr, "architecture", r->in.architecture);
20590                 ndr_print_string(ndr, "driver", r->in.driver);
20591                 ndr->depth--;
20592         }
20593         if (flags & NDR_OUT) {
20594                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20595                 ndr->depth++;
20596                 ndr_print_WERROR(ndr, "result", r->out.result);
20597                 ndr->depth--;
20598         }
20599         ndr->depth--;
20600 }
20601
20602 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20603 {
20604         if (flags & NDR_IN) {
20605                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20606                 if (r->in.server) {
20607                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20608                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20609                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20610                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20611                 }
20612                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20613                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20614                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20615                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20618                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20619                 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));
20620                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20622                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20623                 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));
20624         }
20625         if (flags & NDR_OUT) {
20626                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20627         }
20628         return NDR_ERR_SUCCESS;
20629 }
20630
20631 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20632 {
20633         uint32_t _ptr_server;
20634         TALLOC_CTX *_mem_save_server_0;
20635         if (flags & NDR_IN) {
20636                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20637                 if (_ptr_server) {
20638                         NDR_PULL_ALLOC(ndr, r->in.server);
20639                 } else {
20640                         r->in.server = NULL;
20641                 }
20642                 if (r->in.server) {
20643                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20644                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20645                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20646                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20647                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20648                                 return 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));
20649                         }
20650                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20651                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20652                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20653                 }
20654                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20655                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20656                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20657                         return 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));
20658                 }
20659                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20660                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20661                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20662                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20663                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20664                         return 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));
20665                 }
20666                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20667                 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));
20668                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20669                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20670                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20671                         return 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));
20672                 }
20673                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20674                 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));
20675         }
20676         if (flags & NDR_OUT) {
20677                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20678         }
20679         return NDR_ERR_SUCCESS;
20680 }
20681
20682 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20683 {
20684         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20685         ndr->depth++;
20686         if (flags & NDR_SET_VALUES) {
20687                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20688         }
20689         if (flags & NDR_IN) {
20690                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20691                 ndr->depth++;
20692                 ndr_print_ptr(ndr, "server", r->in.server);
20693                 ndr->depth++;
20694                 if (r->in.server) {
20695                         ndr_print_string(ndr, "server", r->in.server);
20696                 }
20697                 ndr->depth--;
20698                 ndr_print_string(ndr, "architecture", r->in.architecture);
20699                 ndr_print_string(ndr, "path_name", r->in.path_name);
20700                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20701                 ndr->depth--;
20702         }
20703         if (flags & NDR_OUT) {
20704                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20705                 ndr->depth++;
20706                 ndr_print_WERROR(ndr, "result", r->out.result);
20707                 ndr->depth--;
20708         }
20709         ndr->depth--;
20710 }
20711
20712 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20713 {
20714         if (flags & NDR_IN) {
20715                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20716                 if (r->in.servername) {
20717                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20718                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20719                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20720                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20721                 }
20722                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20723                 if (r->in.environment) {
20724                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20725                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20727                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20728                 }
20729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20730                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20731                 if (r->in.buffer) {
20732                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20733                 }
20734                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20735         }
20736         if (flags & NDR_OUT) {
20737                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20738                 if (r->out.info) {
20739                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20740                 }
20741                 if (r->out.needed == NULL) {
20742                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20743                 }
20744                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20745                 if (r->out.count == NULL) {
20746                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20747                 }
20748                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20749                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20750         }
20751         return NDR_ERR_SUCCESS;
20752 }
20753
20754 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20755 {
20756         uint32_t _ptr_servername;
20757         uint32_t _ptr_environment;
20758         uint32_t _ptr_buffer;
20759         uint32_t _ptr_info;
20760         TALLOC_CTX *_mem_save_servername_0;
20761         TALLOC_CTX *_mem_save_environment_0;
20762         TALLOC_CTX *_mem_save_buffer_0;
20763         TALLOC_CTX *_mem_save_info_0;
20764         TALLOC_CTX *_mem_save_needed_0;
20765         TALLOC_CTX *_mem_save_count_0;
20766         if (flags & NDR_IN) {
20767                 ZERO_STRUCT(r->out);
20768
20769                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20770                 if (_ptr_servername) {
20771                         NDR_PULL_ALLOC(ndr, r->in.servername);
20772                 } else {
20773                         r->in.servername = NULL;
20774                 }
20775                 if (r->in.servername) {
20776                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20777                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20778                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20779                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20780                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20781                                 return 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));
20782                         }
20783                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20784                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20785                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20786                 }
20787                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20788                 if (_ptr_environment) {
20789                         NDR_PULL_ALLOC(ndr, r->in.environment);
20790                 } else {
20791                         r->in.environment = NULL;
20792                 }
20793                 if (r->in.environment) {
20794                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20795                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20796                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20797                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20798                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20799                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.environment), ndr_get_array_length(ndr, &r->in.environment));
20800                         }
20801                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20802                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20803                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20804                 }
20805                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20806                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20807                 if (_ptr_buffer) {
20808                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20809                 } else {
20810                         r->in.buffer = NULL;
20811                 }
20812                 if (r->in.buffer) {
20813                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20814                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20815                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20816                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20817                 }
20818                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20819                 NDR_PULL_ALLOC(ndr, r->out.needed);
20820                 ZERO_STRUCTP(r->out.needed);
20821                 NDR_PULL_ALLOC(ndr, r->out.count);
20822                 ZERO_STRUCTP(r->out.count);
20823         }
20824         if (flags & NDR_OUT) {
20825                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20826                 if (_ptr_info) {
20827                         NDR_PULL_ALLOC(ndr, r->out.info);
20828                 } else {
20829                         r->out.info = NULL;
20830                 }
20831                 if (r->out.info) {
20832                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20833                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20834                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20835                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20836                 }
20837                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20838                         NDR_PULL_ALLOC(ndr, r->out.needed);
20839                 }
20840                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20841                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20842                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20843                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20844                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20845                         NDR_PULL_ALLOC(ndr, r->out.count);
20846                 }
20847                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20848                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20849                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20850                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20851                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20852         }
20853         return NDR_ERR_SUCCESS;
20854 }
20855
20856 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20857 {
20858         uint32_t cntr_info_0;
20859         if (flags & NDR_IN) {
20860                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20862         }
20863         if (flags & NDR_OUT) {
20864                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20865                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20866                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20867                 }
20868                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20869                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20870                 }
20871         }
20872         return NDR_ERR_SUCCESS;
20873 }
20874
20875 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20876 {
20877         uint32_t cntr_info_0;
20878         TALLOC_CTX *_mem_save_info_0;
20879         if (flags & NDR_IN) {
20880                 ZERO_STRUCT(r->out);
20881
20882                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20884         }
20885         if (flags & NDR_OUT) {
20886                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20887                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20888                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20889                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20890                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20891                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20892                 }
20893                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20894                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20895                 }
20896                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20897         }
20898         return NDR_ERR_SUCCESS;
20899 }
20900
20901 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20902 {
20903         uint32_t cntr_info_2;
20904         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20905         ndr->depth++;
20906         if (flags & NDR_SET_VALUES) {
20907                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20908         }
20909         if (flags & NDR_IN) {
20910                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20911                 ndr->depth++;
20912                 ndr_print_ptr(ndr, "servername", r->in.servername);
20913                 ndr->depth++;
20914                 if (r->in.servername) {
20915                         ndr_print_string(ndr, "servername", r->in.servername);
20916                 }
20917                 ndr->depth--;
20918                 ndr_print_ptr(ndr, "environment", r->in.environment);
20919                 ndr->depth++;
20920                 if (r->in.environment) {
20921                         ndr_print_string(ndr, "environment", r->in.environment);
20922                 }
20923                 ndr->depth--;
20924                 ndr_print_uint32(ndr, "level", r->in.level);
20925                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20926                 ndr->depth++;
20927                 if (r->in.buffer) {
20928                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20929                 }
20930                 ndr->depth--;
20931                 ndr_print_uint32(ndr, "offered", r->in.offered);
20932                 ndr->depth--;
20933         }
20934         if (flags & NDR_OUT) {
20935                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20936                 ndr->depth++;
20937                 ndr_print_ptr(ndr, "count", r->out.count);
20938                 ndr->depth++;
20939                 ndr_print_uint32(ndr, "count", *r->out.count);
20940                 ndr->depth--;
20941                 ndr_print_ptr(ndr, "info", r->out.info);
20942                 ndr->depth++;
20943                 ndr_print_ptr(ndr, "info", *r->out.info);
20944                 ndr->depth++;
20945                 if (*r->out.info) {
20946                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20947                         ndr->depth++;
20948                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20949                                 char *idx_2=NULL;
20950                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20951                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20952                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20953                                         free(idx_2);
20954                                 }
20955                         }
20956                         ndr->depth--;
20957                 }
20958                 ndr->depth--;
20959                 ndr->depth--;
20960                 ndr_print_ptr(ndr, "needed", r->out.needed);
20961                 ndr->depth++;
20962                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20963                 ndr->depth--;
20964                 ndr_print_WERROR(ndr, "result", r->out.result);
20965                 ndr->depth--;
20966         }
20967         ndr->depth--;
20968 }
20969
20970 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20971 {
20972         if (flags & NDR_IN) {
20973                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20974                 if (r->in.server) {
20975                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20976                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20977                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20978                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20979                 }
20980                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20981                 if (r->in.environment) {
20982                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20983                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20984                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20985                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20986                 }
20987                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20988                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20989                 if (r->in.buffer) {
20990                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20991                 }
20992                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20993         }
20994         if (flags & NDR_OUT) {
20995                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20996                 if (r->out.info) {
20997                         {
20998                                 struct ndr_push *_ndr_info;
20999                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21000                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
21001                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21002                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21003                         }
21004                 }
21005                 if (r->out.needed == NULL) {
21006                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21007                 }
21008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21009                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21010         }
21011         return NDR_ERR_SUCCESS;
21012 }
21013
21014 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
21015 {
21016         uint32_t _ptr_server;
21017         uint32_t _ptr_environment;
21018         uint32_t _ptr_buffer;
21019         uint32_t _ptr_info;
21020         TALLOC_CTX *_mem_save_server_0;
21021         TALLOC_CTX *_mem_save_environment_0;
21022         TALLOC_CTX *_mem_save_buffer_0;
21023         TALLOC_CTX *_mem_save_info_0;
21024         TALLOC_CTX *_mem_save_needed_0;
21025         if (flags & NDR_IN) {
21026                 ZERO_STRUCT(r->out);
21027
21028                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
21029                 if (_ptr_server) {
21030                         NDR_PULL_ALLOC(ndr, r->in.server);
21031                 } else {
21032                         r->in.server = NULL;
21033                 }
21034                 if (r->in.server) {
21035                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
21036                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
21037                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
21038                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
21039                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
21040                                 return 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));
21041                         }
21042                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
21043                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
21044                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
21045                 }
21046                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
21047                 if (_ptr_environment) {
21048                         NDR_PULL_ALLOC(ndr, r->in.environment);
21049                 } else {
21050                         r->in.environment = NULL;
21051                 }
21052                 if (r->in.environment) {
21053                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
21054                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
21055                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
21056                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
21057                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
21058                                 return 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));
21059                         }
21060                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
21061                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
21062                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
21063                 }
21064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21065                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21066                 if (_ptr_buffer) {
21067                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21068                 } else {
21069                         r->in.buffer = NULL;
21070                 }
21071                 if (r->in.buffer) {
21072                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21073                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21074                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
21075                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21076                 }
21077                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21078                 NDR_PULL_ALLOC(ndr, r->out.needed);
21079                 ZERO_STRUCTP(r->out.needed);
21080         }
21081         if (flags & NDR_OUT) {
21082                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
21083                 if (_ptr_info) {
21084                         NDR_PULL_ALLOC(ndr, r->out.info);
21085                 } else {
21086                         r->out.info = NULL;
21087                 }
21088                 if (r->out.info) {
21089                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
21090                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
21091                         {
21092                                 struct ndr_pull *_ndr_info;
21093                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
21094                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
21095                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
21096                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
21097                         }
21098                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
21099                 }
21100                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21101                         NDR_PULL_ALLOC(ndr, r->out.needed);
21102                 }
21103                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21104                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21105                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21106                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21108         }
21109         return NDR_ERR_SUCCESS;
21110 }
21111
21112 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
21113 {
21114         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
21115         ndr->depth++;
21116         if (flags & NDR_SET_VALUES) {
21117                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21118         }
21119         if (flags & NDR_IN) {
21120                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
21121                 ndr->depth++;
21122                 ndr_print_ptr(ndr, "server", r->in.server);
21123                 ndr->depth++;
21124                 if (r->in.server) {
21125                         ndr_print_string(ndr, "server", r->in.server);
21126                 }
21127                 ndr->depth--;
21128                 ndr_print_ptr(ndr, "environment", r->in.environment);
21129                 ndr->depth++;
21130                 if (r->in.environment) {
21131                         ndr_print_string(ndr, "environment", r->in.environment);
21132                 }
21133                 ndr->depth--;
21134                 ndr_print_uint32(ndr, "level", r->in.level);
21135                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21136                 ndr->depth++;
21137                 if (r->in.buffer) {
21138                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
21139                 }
21140                 ndr->depth--;
21141                 ndr_print_uint32(ndr, "offered", r->in.offered);
21142                 ndr->depth--;
21143         }
21144         if (flags & NDR_OUT) {
21145                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
21146                 ndr->depth++;
21147                 ndr_print_ptr(ndr, "info", r->out.info);
21148                 ndr->depth++;
21149                 if (r->out.info) {
21150                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
21151                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
21152                 }
21153                 ndr->depth--;
21154                 ndr_print_ptr(ndr, "needed", r->out.needed);
21155                 ndr->depth++;
21156                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21157                 ndr->depth--;
21158                 ndr_print_WERROR(ndr, "result", r->out.result);
21159                 ndr->depth--;
21160         }
21161         ndr->depth--;
21162 }
21163
21164 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
21165 {
21166         if (flags & NDR_IN) {
21167                 if (r->in.handle == NULL) {
21168                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21169                 }
21170                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21171                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21172                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21173                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21174         }
21175         if (flags & NDR_OUT) {
21176                 if (r->out.job_id == NULL) {
21177                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21178                 }
21179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
21180                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21181         }
21182         return NDR_ERR_SUCCESS;
21183 }
21184
21185 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
21186 {
21187         TALLOC_CTX *_mem_save_handle_0;
21188         TALLOC_CTX *_mem_save_job_id_0;
21189         if (flags & NDR_IN) {
21190                 ZERO_STRUCT(r->out);
21191
21192                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21193                         NDR_PULL_ALLOC(ndr, r->in.handle);
21194                 }
21195                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21196                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21197                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21198                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21199                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21200                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
21201                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21202                 NDR_PULL_ALLOC(ndr, r->out.job_id);
21203                 ZERO_STRUCTP(r->out.job_id);
21204         }
21205         if (flags & NDR_OUT) {
21206                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21207                         NDR_PULL_ALLOC(ndr, r->out.job_id);
21208                 }
21209                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
21210                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
21211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
21212                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
21213                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21214         }
21215         return NDR_ERR_SUCCESS;
21216 }
21217
21218 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
21219 {
21220         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
21221         ndr->depth++;
21222         if (flags & NDR_SET_VALUES) {
21223                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21224         }
21225         if (flags & NDR_IN) {
21226                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
21227                 ndr->depth++;
21228                 ndr_print_ptr(ndr, "handle", r->in.handle);
21229                 ndr->depth++;
21230                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21231                 ndr->depth--;
21232                 ndr_print_uint32(ndr, "level", r->in.level);
21233                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
21234                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
21235                 ndr->depth--;
21236         }
21237         if (flags & NDR_OUT) {
21238                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
21239                 ndr->depth++;
21240                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
21241                 ndr->depth++;
21242                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
21243                 ndr->depth--;
21244                 ndr_print_WERROR(ndr, "result", r->out.result);
21245                 ndr->depth--;
21246         }
21247         ndr->depth--;
21248 }
21249
21250 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
21251 {
21252         if (flags & NDR_IN) {
21253                 if (r->in.handle == NULL) {
21254                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21255                 }
21256                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21257         }
21258         if (flags & NDR_OUT) {
21259                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21260         }
21261         return NDR_ERR_SUCCESS;
21262 }
21263
21264 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
21265 {
21266         TALLOC_CTX *_mem_save_handle_0;
21267         if (flags & NDR_IN) {
21268                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21269                         NDR_PULL_ALLOC(ndr, r->in.handle);
21270                 }
21271                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21272                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21273                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21274                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21275         }
21276         if (flags & NDR_OUT) {
21277                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21278         }
21279         return NDR_ERR_SUCCESS;
21280 }
21281
21282 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
21283 {
21284         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
21285         ndr->depth++;
21286         if (flags & NDR_SET_VALUES) {
21287                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21288         }
21289         if (flags & NDR_IN) {
21290                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
21291                 ndr->depth++;
21292                 ndr_print_ptr(ndr, "handle", r->in.handle);
21293                 ndr->depth++;
21294                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21295                 ndr->depth--;
21296                 ndr->depth--;
21297         }
21298         if (flags & NDR_OUT) {
21299                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21300                 ndr->depth++;
21301                 ndr_print_WERROR(ndr, "result", r->out.result);
21302                 ndr->depth--;
21303         }
21304         ndr->depth--;
21305 }
21306
21307 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21308 {
21309         if (flags & NDR_IN) {
21310                 if (r->in.handle == NULL) {
21311                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21312                 }
21313                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21314                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21316         }
21317         if (flags & NDR_OUT) {
21318                 if (r->out.num_written == NULL) {
21319                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21320                 }
21321                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21322                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21323         }
21324         return NDR_ERR_SUCCESS;
21325 }
21326
21327 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21328 {
21329         TALLOC_CTX *_mem_save_handle_0;
21330         TALLOC_CTX *_mem_save_num_written_0;
21331         if (flags & NDR_IN) {
21332                 ZERO_STRUCT(r->out);
21333
21334                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21335                         NDR_PULL_ALLOC(ndr, r->in.handle);
21336                 }
21337                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21338                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21339                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21340                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21341                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21342                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21343                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21344                 ZERO_STRUCTP(r->out.num_written);
21345         }
21346         if (flags & NDR_OUT) {
21347                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21348                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21349                 }
21350                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21351                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21352                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21353                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21354                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21355         }
21356         return NDR_ERR_SUCCESS;
21357 }
21358
21359 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21360 {
21361         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21362         ndr->depth++;
21363         if (flags & NDR_SET_VALUES) {
21364                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21365         }
21366         if (flags & NDR_IN) {
21367                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21368                 ndr->depth++;
21369                 ndr_print_ptr(ndr, "handle", r->in.handle);
21370                 ndr->depth++;
21371                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21372                 ndr->depth--;
21373                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21374                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21375                 ndr->depth--;
21376         }
21377         if (flags & NDR_OUT) {
21378                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21379                 ndr->depth++;
21380                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21381                 ndr->depth++;
21382                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21383                 ndr->depth--;
21384                 ndr_print_WERROR(ndr, "result", r->out.result);
21385                 ndr->depth--;
21386         }
21387         ndr->depth--;
21388 }
21389
21390 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21391 {
21392         if (flags & NDR_IN) {
21393                 if (r->in.handle == NULL) {
21394                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21395                 }
21396                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21397         }
21398         if (flags & NDR_OUT) {
21399                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21400         }
21401         return NDR_ERR_SUCCESS;
21402 }
21403
21404 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21405 {
21406         TALLOC_CTX *_mem_save_handle_0;
21407         if (flags & NDR_IN) {
21408                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21409                         NDR_PULL_ALLOC(ndr, r->in.handle);
21410                 }
21411                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21412                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21413                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21414                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21415         }
21416         if (flags & NDR_OUT) {
21417                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21418         }
21419         return NDR_ERR_SUCCESS;
21420 }
21421
21422 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21423 {
21424         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21425         ndr->depth++;
21426         if (flags & NDR_SET_VALUES) {
21427                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21428         }
21429         if (flags & NDR_IN) {
21430                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21431                 ndr->depth++;
21432                 ndr_print_ptr(ndr, "handle", r->in.handle);
21433                 ndr->depth++;
21434                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21435                 ndr->depth--;
21436                 ndr->depth--;
21437         }
21438         if (flags & NDR_OUT) {
21439                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21440                 ndr->depth++;
21441                 ndr_print_WERROR(ndr, "result", r->out.result);
21442                 ndr->depth--;
21443         }
21444         ndr->depth--;
21445 }
21446
21447 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21448 {
21449         if (flags & NDR_IN) {
21450                 if (r->in.handle == NULL) {
21451                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21452                 }
21453                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21454         }
21455         if (flags & NDR_OUT) {
21456                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21457         }
21458         return NDR_ERR_SUCCESS;
21459 }
21460
21461 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21462 {
21463         TALLOC_CTX *_mem_save_handle_0;
21464         if (flags & NDR_IN) {
21465                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21466                         NDR_PULL_ALLOC(ndr, r->in.handle);
21467                 }
21468                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21469                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21470                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21471                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21472         }
21473         if (flags & NDR_OUT) {
21474                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21475         }
21476         return NDR_ERR_SUCCESS;
21477 }
21478
21479 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21480 {
21481         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21482         ndr->depth++;
21483         if (flags & NDR_SET_VALUES) {
21484                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21485         }
21486         if (flags & NDR_IN) {
21487                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21488                 ndr->depth++;
21489                 ndr_print_ptr(ndr, "handle", r->in.handle);
21490                 ndr->depth++;
21491                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21492                 ndr->depth--;
21493                 ndr->depth--;
21494         }
21495         if (flags & NDR_OUT) {
21496                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21497                 ndr->depth++;
21498                 ndr_print_WERROR(ndr, "result", r->out.result);
21499                 ndr->depth--;
21500         }
21501         ndr->depth--;
21502 }
21503
21504 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21505 {
21506         if (flags & NDR_IN) {
21507                 if (r->in.handle == NULL) {
21508                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21509                 }
21510                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21512         }
21513         if (flags & NDR_OUT) {
21514                 if (r->out.data == NULL) {
21515                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21516                 }
21517                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21518                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21519                 if (r->out._data_size == NULL) {
21520                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21521                 }
21522                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21523                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21524         }
21525         return NDR_ERR_SUCCESS;
21526 }
21527
21528 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21529 {
21530         TALLOC_CTX *_mem_save_handle_0;
21531         TALLOC_CTX *_mem_save__data_size_0;
21532         if (flags & NDR_IN) {
21533                 ZERO_STRUCT(r->out);
21534
21535                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21536                         NDR_PULL_ALLOC(ndr, r->in.handle);
21537                 }
21538                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21539                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21540                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21541                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21542                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21543                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21544                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21545                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21546                 ZERO_STRUCTP(r->out._data_size);
21547         }
21548         if (flags & NDR_OUT) {
21549                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21550                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21551                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21552                 }
21553                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21554                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21555                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21556                 }
21557                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21558                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21559                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21560                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21562                 if (r->out.data) {
21563                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21564                 }
21565         }
21566         return NDR_ERR_SUCCESS;
21567 }
21568
21569 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21570 {
21571         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21572         ndr->depth++;
21573         if (flags & NDR_SET_VALUES) {
21574                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21575         }
21576         if (flags & NDR_IN) {
21577                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21578                 ndr->depth++;
21579                 ndr_print_ptr(ndr, "handle", r->in.handle);
21580                 ndr->depth++;
21581                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21582                 ndr->depth--;
21583                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21584                 ndr->depth--;
21585         }
21586         if (flags & NDR_OUT) {
21587                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21588                 ndr->depth++;
21589                 ndr_print_ptr(ndr, "data", r->out.data);
21590                 ndr->depth++;
21591                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21592                 ndr->depth--;
21593                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21594                 ndr->depth++;
21595                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21596                 ndr->depth--;
21597                 ndr_print_WERROR(ndr, "result", r->out.result);
21598                 ndr->depth--;
21599         }
21600         ndr->depth--;
21601 }
21602
21603 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21604 {
21605         if (flags & NDR_IN) {
21606                 if (r->in.handle == NULL) {
21607                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21608                 }
21609                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21610         }
21611         if (flags & NDR_OUT) {
21612                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21613         }
21614         return NDR_ERR_SUCCESS;
21615 }
21616
21617 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21618 {
21619         TALLOC_CTX *_mem_save_handle_0;
21620         if (flags & NDR_IN) {
21621                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21622                         NDR_PULL_ALLOC(ndr, r->in.handle);
21623                 }
21624                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21625                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21626                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21627                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21628         }
21629         if (flags & NDR_OUT) {
21630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21631         }
21632         return NDR_ERR_SUCCESS;
21633 }
21634
21635 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21636 {
21637         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21638         ndr->depth++;
21639         if (flags & NDR_SET_VALUES) {
21640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21641         }
21642         if (flags & NDR_IN) {
21643                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21644                 ndr->depth++;
21645                 ndr_print_ptr(ndr, "handle", r->in.handle);
21646                 ndr->depth++;
21647                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21648                 ndr->depth--;
21649                 ndr->depth--;
21650         }
21651         if (flags & NDR_OUT) {
21652                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21653                 ndr->depth++;
21654                 ndr_print_WERROR(ndr, "result", r->out.result);
21655                 ndr->depth--;
21656         }
21657         ndr->depth--;
21658 }
21659
21660 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21661 {
21662         if (flags & NDR_IN) {
21663                 if (r->in.handle == NULL) {
21664                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21665                 }
21666                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21667                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21668                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21669                 if (r->in.buffer) {
21670                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21671                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21672                 }
21673                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21674         }
21675         if (flags & NDR_OUT) {
21676                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21677                 if (r->out.buffer) {
21678                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21679                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21680                 }
21681                 if (r->out.needed == NULL) {
21682                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21683                 }
21684                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21685                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21686         }
21687         return NDR_ERR_SUCCESS;
21688 }
21689
21690 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21691 {
21692         uint32_t _ptr_buffer;
21693         TALLOC_CTX *_mem_save_handle_0;
21694         TALLOC_CTX *_mem_save_buffer_0;
21695         TALLOC_CTX *_mem_save_needed_0;
21696         if (flags & NDR_IN) {
21697                 ZERO_STRUCT(r->out);
21698
21699                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21700                         NDR_PULL_ALLOC(ndr, r->in.handle);
21701                 }
21702                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21703                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21704                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21705                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21706                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21707                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21708                 if (_ptr_buffer) {
21709                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21710                 } else {
21711                         r->in.buffer = NULL;
21712                 }
21713                 if (r->in.buffer) {
21714                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21715                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21716                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21717                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21718                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21719                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21720                 }
21721                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21722                 NDR_PULL_ALLOC(ndr, r->out.needed);
21723                 ZERO_STRUCTP(r->out.needed);
21724                 if (r->in.buffer) {
21725                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21726                 }
21727         }
21728         if (flags & NDR_OUT) {
21729                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21730                 if (_ptr_buffer) {
21731                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21732                 } else {
21733                         r->out.buffer = NULL;
21734                 }
21735                 if (r->out.buffer) {
21736                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21737                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21738                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21739                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21740                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21741                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21742                 }
21743                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21744                         NDR_PULL_ALLOC(ndr, r->out.needed);
21745                 }
21746                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21747                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21748                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21749                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21750                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21751                 if (r->out.buffer) {
21752                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21753                 }
21754         }
21755         return NDR_ERR_SUCCESS;
21756 }
21757
21758 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21759 {
21760         ndr_print_struct(ndr, name, "spoolss_AddJob");
21761         ndr->depth++;
21762         if (flags & NDR_SET_VALUES) {
21763                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21764         }
21765         if (flags & NDR_IN) {
21766                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21767                 ndr->depth++;
21768                 ndr_print_ptr(ndr, "handle", r->in.handle);
21769                 ndr->depth++;
21770                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21771                 ndr->depth--;
21772                 ndr_print_uint32(ndr, "level", r->in.level);
21773                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21774                 ndr->depth++;
21775                 if (r->in.buffer) {
21776                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21777                 }
21778                 ndr->depth--;
21779                 ndr_print_uint32(ndr, "offered", r->in.offered);
21780                 ndr->depth--;
21781         }
21782         if (flags & NDR_OUT) {
21783                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21784                 ndr->depth++;
21785                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21786                 ndr->depth++;
21787                 if (r->out.buffer) {
21788                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21789                 }
21790                 ndr->depth--;
21791                 ndr_print_ptr(ndr, "needed", r->out.needed);
21792                 ndr->depth++;
21793                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21794                 ndr->depth--;
21795                 ndr_print_WERROR(ndr, "result", r->out.result);
21796                 ndr->depth--;
21797         }
21798         ndr->depth--;
21799 }
21800
21801 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21802 {
21803         if (flags & NDR_IN) {
21804                 if (r->in.handle == NULL) {
21805                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21806                 }
21807                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21808                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21809         }
21810         if (flags & NDR_OUT) {
21811                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21812         }
21813         return NDR_ERR_SUCCESS;
21814 }
21815
21816 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21817 {
21818         TALLOC_CTX *_mem_save_handle_0;
21819         if (flags & NDR_IN) {
21820                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21821                         NDR_PULL_ALLOC(ndr, r->in.handle);
21822                 }
21823                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21824                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21825                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21826                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21827                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21828         }
21829         if (flags & NDR_OUT) {
21830                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21831         }
21832         return NDR_ERR_SUCCESS;
21833 }
21834
21835 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21836 {
21837         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21838         ndr->depth++;
21839         if (flags & NDR_SET_VALUES) {
21840                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21841         }
21842         if (flags & NDR_IN) {
21843                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21844                 ndr->depth++;
21845                 ndr_print_ptr(ndr, "handle", r->in.handle);
21846                 ndr->depth++;
21847                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21848                 ndr->depth--;
21849                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21850                 ndr->depth--;
21851         }
21852         if (flags & NDR_OUT) {
21853                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21854                 ndr->depth++;
21855                 ndr_print_WERROR(ndr, "result", r->out.result);
21856                 ndr->depth--;
21857         }
21858         ndr->depth--;
21859 }
21860
21861 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21862 {
21863         if (flags & NDR_IN) {
21864                 if (r->in.handle == NULL) {
21865                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21866                 }
21867                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21869                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21870                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21871                 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));
21872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21873         }
21874         if (flags & NDR_OUT) {
21875                 if (r->out.type == NULL) {
21876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21877                 }
21878                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
21879                 if (r->out.data == NULL) {
21880                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21881                 }
21882                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
21883                 if (r->out.needed == NULL) {
21884                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21885                 }
21886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21887                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21888         }
21889         return NDR_ERR_SUCCESS;
21890 }
21891
21892 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21893 {
21894         TALLOC_CTX *_mem_save_handle_0;
21895         TALLOC_CTX *_mem_save_type_0;
21896         TALLOC_CTX *_mem_save_data_0;
21897         TALLOC_CTX *_mem_save_needed_0;
21898         if (flags & NDR_IN) {
21899                 ZERO_STRUCT(r->out);
21900
21901                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21902                         NDR_PULL_ALLOC(ndr, r->in.handle);
21903                 }
21904                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21905                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21906                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21908                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21909                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21910                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21911                         return 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));
21912                 }
21913                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21914                 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));
21915                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21916                 NDR_PULL_ALLOC(ndr, r->out.type);
21917                 ZERO_STRUCTP(r->out.type);
21918                 NDR_PULL_ALLOC(ndr, r->out.data);
21919                 ZERO_STRUCTP(r->out.data);
21920                 NDR_PULL_ALLOC(ndr, r->out.needed);
21921                 ZERO_STRUCTP(r->out.needed);
21922         }
21923         if (flags & NDR_OUT) {
21924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21925                         NDR_PULL_ALLOC(ndr, r->out.type);
21926                 }
21927                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21928                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21929                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
21930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21931                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21932                         NDR_PULL_ALLOC(ndr, r->out.data);
21933                 }
21934                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21935                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21936                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21937                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21938                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21939                         NDR_PULL_ALLOC(ndr, r->out.needed);
21940                 }
21941                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21942                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21944                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21945                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21946         }
21947         return NDR_ERR_SUCCESS;
21948 }
21949
21950 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21951 {
21952         if (flags & NDR_IN) {
21953                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21954         }
21955         if (flags & NDR_OUT) {
21956                 if (r->out.data == NULL) {
21957                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21958                 }
21959                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
21960                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21961         }
21962         return NDR_ERR_SUCCESS;
21963 }
21964
21965 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21966 {
21967         TALLOC_CTX *_mem_save_data_0;
21968         if (flags & NDR_IN) {
21969                 ZERO_STRUCT(r->out);
21970
21971                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
21972                 NDR_PULL_ALLOC(ndr, r->out.data);
21973                 ZERO_STRUCTP(r->out.data);
21974         }
21975         if (flags & NDR_OUT) {
21976                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21977                         NDR_PULL_ALLOC(ndr, r->out.data);
21978                 }
21979                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21980                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21981                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
21982                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21983                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21984         }
21985         return NDR_ERR_SUCCESS;
21986 }
21987
21988 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21989 {
21990         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21991         ndr->depth++;
21992         if (flags & NDR_SET_VALUES) {
21993                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21994         }
21995         if (flags & NDR_IN) {
21996                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21997                 ndr->depth++;
21998                 ndr_print_ptr(ndr, "handle", r->in.handle);
21999                 ndr->depth++;
22000                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22001                 ndr->depth--;
22002                 ndr_print_string(ndr, "value_name", r->in.value_name);
22003                 ndr_print_uint32(ndr, "offered", r->in.offered);
22004                 ndr->depth--;
22005         }
22006         if (flags & NDR_OUT) {
22007                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
22008                 ndr->depth++;
22009                 ndr_print_ptr(ndr, "type", r->out.type);
22010                 ndr->depth++;
22011                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
22012                 ndr->depth--;
22013                 ndr_print_ptr(ndr, "data", r->out.data);
22014                 ndr->depth++;
22015                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
22016                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
22017                 ndr->depth--;
22018                 ndr_print_ptr(ndr, "needed", r->out.needed);
22019                 ndr->depth++;
22020                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22021                 ndr->depth--;
22022                 ndr_print_WERROR(ndr, "result", r->out.result);
22023                 ndr->depth--;
22024         }
22025         ndr->depth--;
22026 }
22027
22028 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
22029 {
22030         if (flags & NDR_IN) {
22031                 if (r->in.handle == NULL) {
22032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22033                 }
22034                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22035                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22036                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22037                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
22038                 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));
22039                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22040                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
22041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
22042         }
22043         if (flags & NDR_OUT) {
22044                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22045         }
22046         return NDR_ERR_SUCCESS;
22047 }
22048
22049 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
22050 {
22051         if (flags & NDR_IN) {
22052                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
22053         }
22054         if (flags & NDR_OUT) {
22055                 if (r->out.data == NULL) {
22056                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22057                 }
22058                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
22059                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
22060         }
22061         return NDR_ERR_SUCCESS;
22062 }
22063
22064 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
22065 {
22066         TALLOC_CTX *_mem_save_handle_0;
22067         if (flags & NDR_IN) {
22068                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22069                         NDR_PULL_ALLOC(ndr, r->in.handle);
22070                 }
22071                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22072                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22073                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22074                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22075                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
22076                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
22077                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
22078                         return 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));
22079                 }
22080                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
22081                 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));
22082                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
22083                 {
22084                         struct ndr_pull *_ndr_data;
22085                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
22086                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
22087                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
22088                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
22089                 }
22090                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
22091         }
22092         if (flags & NDR_OUT) {
22093                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22094         }
22095         return NDR_ERR_SUCCESS;
22096 }
22097
22098 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
22099 {
22100         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
22101         ndr->depth++;
22102         if (flags & NDR_SET_VALUES) {
22103                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22104         }
22105         if (flags & NDR_IN) {
22106                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
22107                 ndr->depth++;
22108                 ndr_print_ptr(ndr, "handle", r->in.handle);
22109                 ndr->depth++;
22110                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22111                 ndr->depth--;
22112                 ndr_print_string(ndr, "value_name", r->in.value_name);
22113                 ndr_print_winreg_Type(ndr, "type", r->in.type);
22114                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
22115                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
22116                 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);
22117                 ndr->depth--;
22118         }
22119         if (flags & NDR_OUT) {
22120                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
22121                 ndr->depth++;
22122                 ndr_print_WERROR(ndr, "result", r->out.result);
22123                 ndr->depth--;
22124         }
22125         ndr->depth--;
22126 }
22127
22128 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
22129 {
22130         if (flags & NDR_IN) {
22131         }
22132         if (flags & NDR_OUT) {
22133                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22134         }
22135         return NDR_ERR_SUCCESS;
22136 }
22137
22138 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
22139 {
22140         if (flags & NDR_IN) {
22141         }
22142         if (flags & NDR_OUT) {
22143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22144         }
22145         return NDR_ERR_SUCCESS;
22146 }
22147
22148 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
22149 {
22150         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
22151         ndr->depth++;
22152         if (flags & NDR_SET_VALUES) {
22153                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22154         }
22155         if (flags & NDR_IN) {
22156                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
22157                 ndr->depth++;
22158                 ndr->depth--;
22159         }
22160         if (flags & NDR_OUT) {
22161                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
22162                 ndr->depth++;
22163                 ndr_print_WERROR(ndr, "result", r->out.result);
22164                 ndr->depth--;
22165         }
22166         ndr->depth--;
22167 }
22168
22169 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
22170 {
22171         if (flags & NDR_IN) {
22172                 if (r->in.handle == NULL) {
22173                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22174                 }
22175                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22176         }
22177         if (flags & NDR_OUT) {
22178                 if (r->out.handle == NULL) {
22179                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22180                 }
22181                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22182                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22183         }
22184         return NDR_ERR_SUCCESS;
22185 }
22186
22187 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
22188 {
22189         TALLOC_CTX *_mem_save_handle_0;
22190         if (flags & NDR_IN) {
22191                 ZERO_STRUCT(r->out);
22192
22193                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22194                         NDR_PULL_ALLOC(ndr, r->in.handle);
22195                 }
22196                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22197                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22198                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22199                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22200                 NDR_PULL_ALLOC(ndr, r->out.handle);
22201                 *r->out.handle = *r->in.handle;
22202         }
22203         if (flags & NDR_OUT) {
22204                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22205                         NDR_PULL_ALLOC(ndr, r->out.handle);
22206                 }
22207                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22208                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
22209                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
22210                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22211                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22212         }
22213         return NDR_ERR_SUCCESS;
22214 }
22215
22216 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
22217 {
22218         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
22219         ndr->depth++;
22220         if (flags & NDR_SET_VALUES) {
22221                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22222         }
22223         if (flags & NDR_IN) {
22224                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
22225                 ndr->depth++;
22226                 ndr_print_ptr(ndr, "handle", r->in.handle);
22227                 ndr->depth++;
22228                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22229                 ndr->depth--;
22230                 ndr->depth--;
22231         }
22232         if (flags & NDR_OUT) {
22233                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
22234                 ndr->depth++;
22235                 ndr_print_ptr(ndr, "handle", r->out.handle);
22236                 ndr->depth++;
22237                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
22238                 ndr->depth--;
22239                 ndr_print_WERROR(ndr, "result", r->out.result);
22240                 ndr->depth--;
22241         }
22242         ndr->depth--;
22243 }
22244
22245 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
22246 {
22247         if (flags & NDR_IN) {
22248                 if (r->in.handle == NULL) {
22249                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22250                 }
22251                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22252                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22253                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22254                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22255         }
22256         if (flags & NDR_OUT) {
22257                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22258         }
22259         return NDR_ERR_SUCCESS;
22260 }
22261
22262 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
22263 {
22264         TALLOC_CTX *_mem_save_handle_0;
22265         if (flags & NDR_IN) {
22266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22267                         NDR_PULL_ALLOC(ndr, r->in.handle);
22268                 }
22269                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22270                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22271                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22274                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22275                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22276         }
22277         if (flags & NDR_OUT) {
22278                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22279         }
22280         return NDR_ERR_SUCCESS;
22281 }
22282
22283 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
22284 {
22285         ndr_print_struct(ndr, name, "spoolss_AddForm");
22286         ndr->depth++;
22287         if (flags & NDR_SET_VALUES) {
22288                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22289         }
22290         if (flags & NDR_IN) {
22291                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
22292                 ndr->depth++;
22293                 ndr_print_ptr(ndr, "handle", r->in.handle);
22294                 ndr->depth++;
22295                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22296                 ndr->depth--;
22297                 ndr_print_uint32(ndr, "level", r->in.level);
22298                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22299                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22300                 ndr->depth--;
22301         }
22302         if (flags & NDR_OUT) {
22303                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22304                 ndr->depth++;
22305                 ndr_print_WERROR(ndr, "result", r->out.result);
22306                 ndr->depth--;
22307         }
22308         ndr->depth--;
22309 }
22310
22311 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22312 {
22313         if (flags & NDR_IN) {
22314                 if (r->in.handle == NULL) {
22315                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22316                 }
22317                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22318                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22319                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22321                 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));
22322         }
22323         if (flags & NDR_OUT) {
22324                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22325         }
22326         return NDR_ERR_SUCCESS;
22327 }
22328
22329 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22330 {
22331         TALLOC_CTX *_mem_save_handle_0;
22332         if (flags & NDR_IN) {
22333                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22334                         NDR_PULL_ALLOC(ndr, r->in.handle);
22335                 }
22336                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22337                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22338                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22339                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22340                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22341                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22342                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22343                         return 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));
22344                 }
22345                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22346                 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));
22347         }
22348         if (flags & NDR_OUT) {
22349                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22350         }
22351         return NDR_ERR_SUCCESS;
22352 }
22353
22354 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22355 {
22356         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22357         ndr->depth++;
22358         if (flags & NDR_SET_VALUES) {
22359                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22360         }
22361         if (flags & NDR_IN) {
22362                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22363                 ndr->depth++;
22364                 ndr_print_ptr(ndr, "handle", r->in.handle);
22365                 ndr->depth++;
22366                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22367                 ndr->depth--;
22368                 ndr_print_string(ndr, "form_name", r->in.form_name);
22369                 ndr->depth--;
22370         }
22371         if (flags & NDR_OUT) {
22372                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22373                 ndr->depth++;
22374                 ndr_print_WERROR(ndr, "result", r->out.result);
22375                 ndr->depth--;
22376         }
22377         ndr->depth--;
22378 }
22379
22380 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22381 {
22382         if (flags & NDR_IN) {
22383                 if (r->in.handle == NULL) {
22384                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22385                 }
22386                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22387                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22388                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22389                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22390                 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));
22391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22392                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22393                 if (r->in.buffer) {
22394                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22395                 }
22396                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22397         }
22398         if (flags & NDR_OUT) {
22399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22400                 if (r->out.info) {
22401                         {
22402                                 struct ndr_push *_ndr_info;
22403                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22404                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22405                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22406                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22407                         }
22408                 }
22409                 if (r->out.needed == NULL) {
22410                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22411                 }
22412                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22413                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22414         }
22415         return NDR_ERR_SUCCESS;
22416 }
22417
22418 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22419 {
22420         uint32_t _ptr_buffer;
22421         uint32_t _ptr_info;
22422         TALLOC_CTX *_mem_save_handle_0;
22423         TALLOC_CTX *_mem_save_buffer_0;
22424         TALLOC_CTX *_mem_save_info_0;
22425         TALLOC_CTX *_mem_save_needed_0;
22426         if (flags & NDR_IN) {
22427                 ZERO_STRUCT(r->out);
22428
22429                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22430                         NDR_PULL_ALLOC(ndr, r->in.handle);
22431                 }
22432                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22433                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22434                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22435                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22436                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22437                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22438                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22439                         return 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));
22440                 }
22441                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22442                 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));
22443                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22444                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22445                 if (_ptr_buffer) {
22446                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22447                 } else {
22448                         r->in.buffer = NULL;
22449                 }
22450                 if (r->in.buffer) {
22451                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22452                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22453                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22454                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22455                 }
22456                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22457                 NDR_PULL_ALLOC(ndr, r->out.needed);
22458                 ZERO_STRUCTP(r->out.needed);
22459         }
22460         if (flags & NDR_OUT) {
22461                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22462                 if (_ptr_info) {
22463                         NDR_PULL_ALLOC(ndr, r->out.info);
22464                 } else {
22465                         r->out.info = NULL;
22466                 }
22467                 if (r->out.info) {
22468                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22469                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22470                         {
22471                                 struct ndr_pull *_ndr_info;
22472                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22473                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22474                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22475                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22476                         }
22477                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22478                 }
22479                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22480                         NDR_PULL_ALLOC(ndr, r->out.needed);
22481                 }
22482                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22483                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22484                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22485                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22486                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22487         }
22488         return NDR_ERR_SUCCESS;
22489 }
22490
22491 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22492 {
22493         ndr_print_struct(ndr, name, "spoolss_GetForm");
22494         ndr->depth++;
22495         if (flags & NDR_SET_VALUES) {
22496                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22497         }
22498         if (flags & NDR_IN) {
22499                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22500                 ndr->depth++;
22501                 ndr_print_ptr(ndr, "handle", r->in.handle);
22502                 ndr->depth++;
22503                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22504                 ndr->depth--;
22505                 ndr_print_string(ndr, "form_name", r->in.form_name);
22506                 ndr_print_uint32(ndr, "level", r->in.level);
22507                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22508                 ndr->depth++;
22509                 if (r->in.buffer) {
22510                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22511                 }
22512                 ndr->depth--;
22513                 ndr_print_uint32(ndr, "offered", r->in.offered);
22514                 ndr->depth--;
22515         }
22516         if (flags & NDR_OUT) {
22517                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22518                 ndr->depth++;
22519                 ndr_print_ptr(ndr, "info", r->out.info);
22520                 ndr->depth++;
22521                 if (r->out.info) {
22522                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22523                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22524                 }
22525                 ndr->depth--;
22526                 ndr_print_ptr(ndr, "needed", r->out.needed);
22527                 ndr->depth++;
22528                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22529                 ndr->depth--;
22530                 ndr_print_WERROR(ndr, "result", r->out.result);
22531                 ndr->depth--;
22532         }
22533         ndr->depth--;
22534 }
22535
22536 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22537 {
22538         if (flags & NDR_IN) {
22539                 if (r->in.handle == NULL) {
22540                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22541                 }
22542                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22543                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22544                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22545                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22546                 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));
22547                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22548                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22549                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22550         }
22551         if (flags & NDR_OUT) {
22552                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22553         }
22554         return NDR_ERR_SUCCESS;
22555 }
22556
22557 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22558 {
22559         TALLOC_CTX *_mem_save_handle_0;
22560         if (flags & NDR_IN) {
22561                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22562                         NDR_PULL_ALLOC(ndr, r->in.handle);
22563                 }
22564                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22565                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22566                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22567                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22568                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22569                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22570                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22571                         return 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));
22572                 }
22573                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22574                 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));
22575                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22576                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22577                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22578         }
22579         if (flags & NDR_OUT) {
22580                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22581         }
22582         return NDR_ERR_SUCCESS;
22583 }
22584
22585 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22586 {
22587         ndr_print_struct(ndr, name, "spoolss_SetForm");
22588         ndr->depth++;
22589         if (flags & NDR_SET_VALUES) {
22590                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22591         }
22592         if (flags & NDR_IN) {
22593                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22594                 ndr->depth++;
22595                 ndr_print_ptr(ndr, "handle", r->in.handle);
22596                 ndr->depth++;
22597                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22598                 ndr->depth--;
22599                 ndr_print_string(ndr, "form_name", r->in.form_name);
22600                 ndr_print_uint32(ndr, "level", r->in.level);
22601                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22602                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22603                 ndr->depth--;
22604         }
22605         if (flags & NDR_OUT) {
22606                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22607                 ndr->depth++;
22608                 ndr_print_WERROR(ndr, "result", r->out.result);
22609                 ndr->depth--;
22610         }
22611         ndr->depth--;
22612 }
22613
22614 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22615 {
22616         if (flags & NDR_IN) {
22617                 if (r->in.handle == NULL) {
22618                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22619                 }
22620                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22621                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22622                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22623                 if (r->in.buffer) {
22624                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22625                 }
22626                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22627         }
22628         if (flags & NDR_OUT) {
22629                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22630                 if (r->out.info) {
22631                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22632                 }
22633                 if (r->out.needed == NULL) {
22634                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22635                 }
22636                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22637                 if (r->out.count == NULL) {
22638                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22639                 }
22640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22641                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22642         }
22643         return NDR_ERR_SUCCESS;
22644 }
22645
22646 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22647 {
22648         uint32_t _ptr_buffer;
22649         uint32_t _ptr_info;
22650         TALLOC_CTX *_mem_save_handle_0;
22651         TALLOC_CTX *_mem_save_buffer_0;
22652         TALLOC_CTX *_mem_save_info_0;
22653         TALLOC_CTX *_mem_save_needed_0;
22654         TALLOC_CTX *_mem_save_count_0;
22655         if (flags & NDR_IN) {
22656                 ZERO_STRUCT(r->out);
22657
22658                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22659                         NDR_PULL_ALLOC(ndr, r->in.handle);
22660                 }
22661                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22662                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22663                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22664                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22665                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22666                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22667                 if (_ptr_buffer) {
22668                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22669                 } else {
22670                         r->in.buffer = NULL;
22671                 }
22672                 if (r->in.buffer) {
22673                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22674                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22675                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22677                 }
22678                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22679                 NDR_PULL_ALLOC(ndr, r->out.needed);
22680                 ZERO_STRUCTP(r->out.needed);
22681                 NDR_PULL_ALLOC(ndr, r->out.count);
22682                 ZERO_STRUCTP(r->out.count);
22683         }
22684         if (flags & NDR_OUT) {
22685                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22686                 if (_ptr_info) {
22687                         NDR_PULL_ALLOC(ndr, r->out.info);
22688                 } else {
22689                         r->out.info = NULL;
22690                 }
22691                 if (r->out.info) {
22692                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22693                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22694                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22696                 }
22697                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22698                         NDR_PULL_ALLOC(ndr, r->out.needed);
22699                 }
22700                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22701                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22703                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22704                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22705                         NDR_PULL_ALLOC(ndr, r->out.count);
22706                 }
22707                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22708                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22709                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22711                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22712         }
22713         return NDR_ERR_SUCCESS;
22714 }
22715
22716 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22717 {
22718         uint32_t cntr_info_0;
22719         if (flags & NDR_IN) {
22720                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22721                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22722         }
22723         if (flags & NDR_OUT) {
22724                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22725                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22726                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22727                 }
22728                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22729                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22730                 }
22731         }
22732         return NDR_ERR_SUCCESS;
22733 }
22734
22735 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22736 {
22737         uint32_t cntr_info_0;
22738         TALLOC_CTX *_mem_save_info_0;
22739         if (flags & NDR_IN) {
22740                 ZERO_STRUCT(r->out);
22741
22742                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22743                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22744         }
22745         if (flags & NDR_OUT) {
22746                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22747                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22748                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22749                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22750                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22751                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22752                 }
22753                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22754                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22755                 }
22756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22757         }
22758         return NDR_ERR_SUCCESS;
22759 }
22760
22761 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22762 {
22763         uint32_t cntr_info_2;
22764         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22765         ndr->depth++;
22766         if (flags & NDR_SET_VALUES) {
22767                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22768         }
22769         if (flags & NDR_IN) {
22770                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22771                 ndr->depth++;
22772                 ndr_print_ptr(ndr, "handle", r->in.handle);
22773                 ndr->depth++;
22774                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22775                 ndr->depth--;
22776                 ndr_print_uint32(ndr, "level", r->in.level);
22777                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22778                 ndr->depth++;
22779                 if (r->in.buffer) {
22780                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22781                 }
22782                 ndr->depth--;
22783                 ndr_print_uint32(ndr, "offered", r->in.offered);
22784                 ndr->depth--;
22785         }
22786         if (flags & NDR_OUT) {
22787                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22788                 ndr->depth++;
22789                 ndr_print_ptr(ndr, "count", r->out.count);
22790                 ndr->depth++;
22791                 ndr_print_uint32(ndr, "count", *r->out.count);
22792                 ndr->depth--;
22793                 ndr_print_ptr(ndr, "info", r->out.info);
22794                 ndr->depth++;
22795                 ndr_print_ptr(ndr, "info", *r->out.info);
22796                 ndr->depth++;
22797                 if (*r->out.info) {
22798                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22799                         ndr->depth++;
22800                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22801                                 char *idx_2=NULL;
22802                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22803                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22804                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22805                                         free(idx_2);
22806                                 }
22807                         }
22808                         ndr->depth--;
22809                 }
22810                 ndr->depth--;
22811                 ndr->depth--;
22812                 ndr_print_ptr(ndr, "needed", r->out.needed);
22813                 ndr->depth++;
22814                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22815                 ndr->depth--;
22816                 ndr_print_WERROR(ndr, "result", r->out.result);
22817                 ndr->depth--;
22818         }
22819         ndr->depth--;
22820 }
22821
22822 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22823 {
22824         if (flags & NDR_IN) {
22825                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22826                 if (r->in.servername) {
22827                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22828                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22829                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22830                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22831                 }
22832                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22833                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22834                 if (r->in.buffer) {
22835                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22836                 }
22837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22838         }
22839         if (flags & NDR_OUT) {
22840                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22841                 if (r->out.info) {
22842                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22843                 }
22844                 if (r->out.needed == NULL) {
22845                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22846                 }
22847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22848                 if (r->out.count == NULL) {
22849                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22850                 }
22851                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22852                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22853         }
22854         return NDR_ERR_SUCCESS;
22855 }
22856
22857 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22858 {
22859         uint32_t _ptr_servername;
22860         uint32_t _ptr_buffer;
22861         uint32_t _ptr_info;
22862         TALLOC_CTX *_mem_save_servername_0;
22863         TALLOC_CTX *_mem_save_buffer_0;
22864         TALLOC_CTX *_mem_save_info_0;
22865         TALLOC_CTX *_mem_save_needed_0;
22866         TALLOC_CTX *_mem_save_count_0;
22867         if (flags & NDR_IN) {
22868                 ZERO_STRUCT(r->out);
22869
22870                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22871                 if (_ptr_servername) {
22872                         NDR_PULL_ALLOC(ndr, r->in.servername);
22873                 } else {
22874                         r->in.servername = NULL;
22875                 }
22876                 if (r->in.servername) {
22877                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22878                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22879                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22880                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22881                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22882                                 return 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));
22883                         }
22884                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22885                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22886                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22887                 }
22888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22889                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22890                 if (_ptr_buffer) {
22891                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22892                 } else {
22893                         r->in.buffer = NULL;
22894                 }
22895                 if (r->in.buffer) {
22896                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22897                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22898                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22899                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22900                 }
22901                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22902                 NDR_PULL_ALLOC(ndr, r->out.needed);
22903                 ZERO_STRUCTP(r->out.needed);
22904                 NDR_PULL_ALLOC(ndr, r->out.count);
22905                 ZERO_STRUCTP(r->out.count);
22906         }
22907         if (flags & NDR_OUT) {
22908                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22909                 if (_ptr_info) {
22910                         NDR_PULL_ALLOC(ndr, r->out.info);
22911                 } else {
22912                         r->out.info = NULL;
22913                 }
22914                 if (r->out.info) {
22915                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22916                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22917                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22918                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22919                 }
22920                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22921                         NDR_PULL_ALLOC(ndr, r->out.needed);
22922                 }
22923                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22924                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22925                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22926                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22927                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22928                         NDR_PULL_ALLOC(ndr, r->out.count);
22929                 }
22930                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22931                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22932                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22933                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22934                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22935         }
22936         return NDR_ERR_SUCCESS;
22937 }
22938
22939 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22940 {
22941         uint32_t cntr_info_0;
22942         if (flags & NDR_IN) {
22943                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22944                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22945         }
22946         if (flags & NDR_OUT) {
22947                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22948                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22949                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22950                 }
22951                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22952                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22953                 }
22954         }
22955         return NDR_ERR_SUCCESS;
22956 }
22957
22958 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22959 {
22960         uint32_t cntr_info_0;
22961         TALLOC_CTX *_mem_save_info_0;
22962         if (flags & NDR_IN) {
22963                 ZERO_STRUCT(r->out);
22964
22965                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22966                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22967         }
22968         if (flags & NDR_OUT) {
22969                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22970                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22971                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22972                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22973                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22974                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22975                 }
22976                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22977                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22978                 }
22979                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22980         }
22981         return NDR_ERR_SUCCESS;
22982 }
22983
22984 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22985 {
22986         uint32_t cntr_info_2;
22987         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22988         ndr->depth++;
22989         if (flags & NDR_SET_VALUES) {
22990                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22991         }
22992         if (flags & NDR_IN) {
22993                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22994                 ndr->depth++;
22995                 ndr_print_ptr(ndr, "servername", r->in.servername);
22996                 ndr->depth++;
22997                 if (r->in.servername) {
22998                         ndr_print_string(ndr, "servername", r->in.servername);
22999                 }
23000                 ndr->depth--;
23001                 ndr_print_uint32(ndr, "level", r->in.level);
23002                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23003                 ndr->depth++;
23004                 if (r->in.buffer) {
23005                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23006                 }
23007                 ndr->depth--;
23008                 ndr_print_uint32(ndr, "offered", r->in.offered);
23009                 ndr->depth--;
23010         }
23011         if (flags & NDR_OUT) {
23012                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
23013                 ndr->depth++;
23014                 ndr_print_ptr(ndr, "count", r->out.count);
23015                 ndr->depth++;
23016                 ndr_print_uint32(ndr, "count", *r->out.count);
23017                 ndr->depth--;
23018                 ndr_print_ptr(ndr, "info", r->out.info);
23019                 ndr->depth++;
23020                 ndr_print_ptr(ndr, "info", *r->out.info);
23021                 ndr->depth++;
23022                 if (*r->out.info) {
23023                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23024                         ndr->depth++;
23025                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23026                                 char *idx_2=NULL;
23027                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23028                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23029                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23030                                         free(idx_2);
23031                                 }
23032                         }
23033                         ndr->depth--;
23034                 }
23035                 ndr->depth--;
23036                 ndr->depth--;
23037                 ndr_print_ptr(ndr, "needed", r->out.needed);
23038                 ndr->depth++;
23039                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23040                 ndr->depth--;
23041                 ndr_print_WERROR(ndr, "result", r->out.result);
23042                 ndr->depth--;
23043         }
23044         ndr->depth--;
23045 }
23046
23047 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
23048 {
23049         if (flags & NDR_IN) {
23050                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23051                 if (r->in.servername) {
23052                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23055                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23056                 }
23057                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23058                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23059                 if (r->in.buffer) {
23060                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23061                 }
23062                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23063         }
23064         if (flags & NDR_OUT) {
23065                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23066                 if (r->out.info) {
23067                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23068                 }
23069                 if (r->out.needed == NULL) {
23070                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23071                 }
23072                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23073                 if (r->out.count == NULL) {
23074                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23075                 }
23076                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23077                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23078         }
23079         return NDR_ERR_SUCCESS;
23080 }
23081
23082 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
23083 {
23084         uint32_t _ptr_servername;
23085         uint32_t _ptr_buffer;
23086         uint32_t _ptr_info;
23087         TALLOC_CTX *_mem_save_servername_0;
23088         TALLOC_CTX *_mem_save_buffer_0;
23089         TALLOC_CTX *_mem_save_info_0;
23090         TALLOC_CTX *_mem_save_needed_0;
23091         TALLOC_CTX *_mem_save_count_0;
23092         if (flags & NDR_IN) {
23093                 ZERO_STRUCT(r->out);
23094
23095                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23096                 if (_ptr_servername) {
23097                         NDR_PULL_ALLOC(ndr, r->in.servername);
23098                 } else {
23099                         r->in.servername = NULL;
23100                 }
23101                 if (r->in.servername) {
23102                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23103                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23104                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23105                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23106                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23107                                 return 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));
23108                         }
23109                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23110                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23111                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23112                 }
23113                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23114                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23115                 if (_ptr_buffer) {
23116                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23117                 } else {
23118                         r->in.buffer = NULL;
23119                 }
23120                 if (r->in.buffer) {
23121                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23122                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23123                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23124                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23125                 }
23126                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23127                 NDR_PULL_ALLOC(ndr, r->out.needed);
23128                 ZERO_STRUCTP(r->out.needed);
23129                 NDR_PULL_ALLOC(ndr, r->out.count);
23130                 ZERO_STRUCTP(r->out.count);
23131         }
23132         if (flags & NDR_OUT) {
23133                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23134                 if (_ptr_info) {
23135                         NDR_PULL_ALLOC(ndr, r->out.info);
23136                 } else {
23137                         r->out.info = NULL;
23138                 }
23139                 if (r->out.info) {
23140                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23141                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23142                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23143                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23144                 }
23145                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23146                         NDR_PULL_ALLOC(ndr, r->out.needed);
23147                 }
23148                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23149                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23150                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23151                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23152                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23153                         NDR_PULL_ALLOC(ndr, r->out.count);
23154                 }
23155                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23156                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23157                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23158                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23159                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23160         }
23161         return NDR_ERR_SUCCESS;
23162 }
23163
23164 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
23165 {
23166         uint32_t cntr_info_0;
23167         if (flags & NDR_IN) {
23168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23169                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23170         }
23171         if (flags & NDR_OUT) {
23172                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23173                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23174                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23175                 }
23176                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23177                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23178                 }
23179         }
23180         return NDR_ERR_SUCCESS;
23181 }
23182
23183 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
23184 {
23185         uint32_t cntr_info_0;
23186         TALLOC_CTX *_mem_save_info_0;
23187         if (flags & NDR_IN) {
23188                 ZERO_STRUCT(r->out);
23189
23190                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23191                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23192         }
23193         if (flags & NDR_OUT) {
23194                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23195                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23196                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23197                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23198                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23199                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23200                 }
23201                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23202                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23203                 }
23204                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23205         }
23206         return NDR_ERR_SUCCESS;
23207 }
23208
23209 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
23210 {
23211         uint32_t cntr_info_2;
23212         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
23213         ndr->depth++;
23214         if (flags & NDR_SET_VALUES) {
23215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23216         }
23217         if (flags & NDR_IN) {
23218                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
23219                 ndr->depth++;
23220                 ndr_print_ptr(ndr, "servername", r->in.servername);
23221                 ndr->depth++;
23222                 if (r->in.servername) {
23223                         ndr_print_string(ndr, "servername", r->in.servername);
23224                 }
23225                 ndr->depth--;
23226                 ndr_print_uint32(ndr, "level", r->in.level);
23227                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23228                 ndr->depth++;
23229                 if (r->in.buffer) {
23230                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23231                 }
23232                 ndr->depth--;
23233                 ndr_print_uint32(ndr, "offered", r->in.offered);
23234                 ndr->depth--;
23235         }
23236         if (flags & NDR_OUT) {
23237                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
23238                 ndr->depth++;
23239                 ndr_print_ptr(ndr, "count", r->out.count);
23240                 ndr->depth++;
23241                 ndr_print_uint32(ndr, "count", *r->out.count);
23242                 ndr->depth--;
23243                 ndr_print_ptr(ndr, "info", r->out.info);
23244                 ndr->depth++;
23245                 ndr_print_ptr(ndr, "info", *r->out.info);
23246                 ndr->depth++;
23247                 if (*r->out.info) {
23248                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23249                         ndr->depth++;
23250                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23251                                 char *idx_2=NULL;
23252                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23253                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23254                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23255                                         free(idx_2);
23256                                 }
23257                         }
23258                         ndr->depth--;
23259                 }
23260                 ndr->depth--;
23261                 ndr->depth--;
23262                 ndr_print_ptr(ndr, "needed", r->out.needed);
23263                 ndr->depth++;
23264                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23265                 ndr->depth--;
23266                 ndr_print_WERROR(ndr, "result", r->out.result);
23267                 ndr->depth--;
23268         }
23269         ndr->depth--;
23270 }
23271
23272 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
23273 {
23274         if (flags & NDR_IN) {
23275                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
23276                 if (r->in.server_name) {
23277                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23278                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23279                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23280                         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));
23281                 }
23282                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
23283                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23284                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23285                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23286                 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));
23287         }
23288         if (flags & NDR_OUT) {
23289                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23290         }
23291         return NDR_ERR_SUCCESS;
23292 }
23293
23294 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23295 {
23296         uint32_t _ptr_server_name;
23297         TALLOC_CTX *_mem_save_server_name_0;
23298         if (flags & NDR_IN) {
23299                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23300                 if (_ptr_server_name) {
23301                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23302                 } else {
23303                         r->in.server_name = NULL;
23304                 }
23305                 if (r->in.server_name) {
23306                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23307                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23308                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23309                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23310                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23311                                 return 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));
23312                         }
23313                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23314                         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));
23315                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23316                 }
23317                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23318                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23319                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23320                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23321                         return 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));
23322                 }
23323                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23324                 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));
23325         }
23326         if (flags & NDR_OUT) {
23327                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23328         }
23329         return NDR_ERR_SUCCESS;
23330 }
23331
23332 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23333 {
23334         ndr_print_struct(ndr, name, "spoolss_AddPort");
23335         ndr->depth++;
23336         if (flags & NDR_SET_VALUES) {
23337                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23338         }
23339         if (flags & NDR_IN) {
23340                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23341                 ndr->depth++;
23342                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23343                 ndr->depth++;
23344                 if (r->in.server_name) {
23345                         ndr_print_string(ndr, "server_name", r->in.server_name);
23346                 }
23347                 ndr->depth--;
23348                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23349                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23350                 ndr->depth--;
23351         }
23352         if (flags & NDR_OUT) {
23353                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23354                 ndr->depth++;
23355                 ndr_print_WERROR(ndr, "result", r->out.result);
23356                 ndr->depth--;
23357         }
23358         ndr->depth--;
23359 }
23360
23361 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23362 {
23363         if (flags & NDR_IN) {
23364         }
23365         if (flags & NDR_OUT) {
23366                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23367         }
23368         return NDR_ERR_SUCCESS;
23369 }
23370
23371 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23372 {
23373         if (flags & NDR_IN) {
23374         }
23375         if (flags & NDR_OUT) {
23376                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23377         }
23378         return NDR_ERR_SUCCESS;
23379 }
23380
23381 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23382 {
23383         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23384         ndr->depth++;
23385         if (flags & NDR_SET_VALUES) {
23386                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23387         }
23388         if (flags & NDR_IN) {
23389                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23390                 ndr->depth++;
23391                 ndr->depth--;
23392         }
23393         if (flags & NDR_OUT) {
23394                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23395                 ndr->depth++;
23396                 ndr_print_WERROR(ndr, "result", r->out.result);
23397                 ndr->depth--;
23398         }
23399         ndr->depth--;
23400 }
23401
23402 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23403 {
23404         if (flags & NDR_IN) {
23405         }
23406         if (flags & NDR_OUT) {
23407                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23408         }
23409         return NDR_ERR_SUCCESS;
23410 }
23411
23412 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23413 {
23414         if (flags & NDR_IN) {
23415         }
23416         if (flags & NDR_OUT) {
23417                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23418         }
23419         return NDR_ERR_SUCCESS;
23420 }
23421
23422 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23423 {
23424         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23425         ndr->depth++;
23426         if (flags & NDR_SET_VALUES) {
23427                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23428         }
23429         if (flags & NDR_IN) {
23430                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23431                 ndr->depth++;
23432                 ndr->depth--;
23433         }
23434         if (flags & NDR_OUT) {
23435                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23436                 ndr->depth++;
23437                 ndr_print_WERROR(ndr, "result", r->out.result);
23438                 ndr->depth--;
23439         }
23440         ndr->depth--;
23441 }
23442
23443 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23444 {
23445         if (flags & NDR_IN) {
23446         }
23447         if (flags & NDR_OUT) {
23448                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23449         }
23450         return NDR_ERR_SUCCESS;
23451 }
23452
23453 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23454 {
23455         if (flags & NDR_IN) {
23456         }
23457         if (flags & NDR_OUT) {
23458                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23459         }
23460         return NDR_ERR_SUCCESS;
23461 }
23462
23463 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23464 {
23465         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23466         ndr->depth++;
23467         if (flags & NDR_SET_VALUES) {
23468                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23469         }
23470         if (flags & NDR_IN) {
23471                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23472                 ndr->depth++;
23473                 ndr->depth--;
23474         }
23475         if (flags & NDR_OUT) {
23476                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23477                 ndr->depth++;
23478                 ndr_print_WERROR(ndr, "result", r->out.result);
23479                 ndr->depth--;
23480         }
23481         ndr->depth--;
23482 }
23483
23484 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23485 {
23486         if (flags & NDR_IN) {
23487         }
23488         if (flags & NDR_OUT) {
23489                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23490         }
23491         return NDR_ERR_SUCCESS;
23492 }
23493
23494 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23495 {
23496         if (flags & NDR_IN) {
23497         }
23498         if (flags & NDR_OUT) {
23499                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23500         }
23501         return NDR_ERR_SUCCESS;
23502 }
23503
23504 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23505 {
23506         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23507         ndr->depth++;
23508         if (flags & NDR_SET_VALUES) {
23509                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23510         }
23511         if (flags & NDR_IN) {
23512                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23513                 ndr->depth++;
23514                 ndr->depth--;
23515         }
23516         if (flags & NDR_OUT) {
23517                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23518                 ndr->depth++;
23519                 ndr_print_WERROR(ndr, "result", r->out.result);
23520                 ndr->depth--;
23521         }
23522         ndr->depth--;
23523 }
23524
23525 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23526 {
23527         if (flags & NDR_IN) {
23528         }
23529         if (flags & NDR_OUT) {
23530                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23531         }
23532         return NDR_ERR_SUCCESS;
23533 }
23534
23535 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23536 {
23537         if (flags & NDR_IN) {
23538         }
23539         if (flags & NDR_OUT) {
23540                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23541         }
23542         return NDR_ERR_SUCCESS;
23543 }
23544
23545 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23546 {
23547         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23548         ndr->depth++;
23549         if (flags & NDR_SET_VALUES) {
23550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23551         }
23552         if (flags & NDR_IN) {
23553                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23554                 ndr->depth++;
23555                 ndr->depth--;
23556         }
23557         if (flags & NDR_OUT) {
23558                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23559                 ndr->depth++;
23560                 ndr_print_WERROR(ndr, "result", r->out.result);
23561                 ndr->depth--;
23562         }
23563         ndr->depth--;
23564 }
23565
23566 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23567 {
23568         if (flags & NDR_IN) {
23569         }
23570         if (flags & NDR_OUT) {
23571                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23572         }
23573         return NDR_ERR_SUCCESS;
23574 }
23575
23576 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23577 {
23578         if (flags & NDR_IN) {
23579         }
23580         if (flags & NDR_OUT) {
23581                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23582         }
23583         return NDR_ERR_SUCCESS;
23584 }
23585
23586 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23587 {
23588         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23589         ndr->depth++;
23590         if (flags & NDR_SET_VALUES) {
23591                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23592         }
23593         if (flags & NDR_IN) {
23594                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23595                 ndr->depth++;
23596                 ndr->depth--;
23597         }
23598         if (flags & NDR_OUT) {
23599                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23600                 ndr->depth++;
23601                 ndr_print_WERROR(ndr, "result", r->out.result);
23602                 ndr->depth--;
23603         }
23604         ndr->depth--;
23605 }
23606
23607 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23608 {
23609         if (flags & NDR_IN) {
23610         }
23611         if (flags & NDR_OUT) {
23612                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23613         }
23614         return NDR_ERR_SUCCESS;
23615 }
23616
23617 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23618 {
23619         if (flags & NDR_IN) {
23620         }
23621         if (flags & NDR_OUT) {
23622                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23623         }
23624         return NDR_ERR_SUCCESS;
23625 }
23626
23627 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23628 {
23629         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23630         ndr->depth++;
23631         if (flags & NDR_SET_VALUES) {
23632                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23633         }
23634         if (flags & NDR_IN) {
23635                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23636                 ndr->depth++;
23637                 ndr->depth--;
23638         }
23639         if (flags & NDR_OUT) {
23640                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23641                 ndr->depth++;
23642                 ndr_print_WERROR(ndr, "result", r->out.result);
23643                 ndr->depth--;
23644         }
23645         ndr->depth--;
23646 }
23647
23648 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23649 {
23650         if (flags & NDR_IN) {
23651         }
23652         if (flags & NDR_OUT) {
23653                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23654         }
23655         return NDR_ERR_SUCCESS;
23656 }
23657
23658 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23659 {
23660         if (flags & NDR_IN) {
23661         }
23662         if (flags & NDR_OUT) {
23663                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23664         }
23665         return NDR_ERR_SUCCESS;
23666 }
23667
23668 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23669 {
23670         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23671         ndr->depth++;
23672         if (flags & NDR_SET_VALUES) {
23673                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23674         }
23675         if (flags & NDR_IN) {
23676                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23677                 ndr->depth++;
23678                 ndr->depth--;
23679         }
23680         if (flags & NDR_OUT) {
23681                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23682                 ndr->depth++;
23683                 ndr_print_WERROR(ndr, "result", r->out.result);
23684                 ndr->depth--;
23685         }
23686         ndr->depth--;
23687 }
23688
23689 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23690 {
23691         if (flags & NDR_IN) {
23692         }
23693         if (flags & NDR_OUT) {
23694                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23695         }
23696         return NDR_ERR_SUCCESS;
23697 }
23698
23699 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23700 {
23701         if (flags & NDR_IN) {
23702         }
23703         if (flags & NDR_OUT) {
23704                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23705         }
23706         return NDR_ERR_SUCCESS;
23707 }
23708
23709 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23710 {
23711         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23712         ndr->depth++;
23713         if (flags & NDR_SET_VALUES) {
23714                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23715         }
23716         if (flags & NDR_IN) {
23717                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23718                 ndr->depth++;
23719                 ndr->depth--;
23720         }
23721         if (flags & NDR_OUT) {
23722                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23723                 ndr->depth++;
23724                 ndr_print_WERROR(ndr, "result", r->out.result);
23725                 ndr->depth--;
23726         }
23727         ndr->depth--;
23728 }
23729
23730 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23731 {
23732         if (flags & NDR_IN) {
23733         }
23734         if (flags & NDR_OUT) {
23735                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23736         }
23737         return NDR_ERR_SUCCESS;
23738 }
23739
23740 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23741 {
23742         if (flags & NDR_IN) {
23743         }
23744         if (flags & NDR_OUT) {
23745                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23746         }
23747         return NDR_ERR_SUCCESS;
23748 }
23749
23750 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23751 {
23752         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23753         ndr->depth++;
23754         if (flags & NDR_SET_VALUES) {
23755                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23756         }
23757         if (flags & NDR_IN) {
23758                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23759                 ndr->depth++;
23760                 ndr->depth--;
23761         }
23762         if (flags & NDR_OUT) {
23763                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23764                 ndr->depth++;
23765                 ndr_print_WERROR(ndr, "result", r->out.result);
23766                 ndr->depth--;
23767         }
23768         ndr->depth--;
23769 }
23770
23771 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23772 {
23773         if (flags & NDR_IN) {
23774         }
23775         if (flags & NDR_OUT) {
23776                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23777         }
23778         return NDR_ERR_SUCCESS;
23779 }
23780
23781 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23782 {
23783         if (flags & NDR_IN) {
23784         }
23785         if (flags & NDR_OUT) {
23786                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23787         }
23788         return NDR_ERR_SUCCESS;
23789 }
23790
23791 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23792 {
23793         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23794         ndr->depth++;
23795         if (flags & NDR_SET_VALUES) {
23796                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23797         }
23798         if (flags & NDR_IN) {
23799                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23800                 ndr->depth++;
23801                 ndr->depth--;
23802         }
23803         if (flags & NDR_OUT) {
23804                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23805                 ndr->depth++;
23806                 ndr_print_WERROR(ndr, "result", r->out.result);
23807                 ndr->depth--;
23808         }
23809         ndr->depth--;
23810 }
23811
23812 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23813 {
23814         if (flags & NDR_IN) {
23815         }
23816         if (flags & NDR_OUT) {
23817                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23818         }
23819         return NDR_ERR_SUCCESS;
23820 }
23821
23822 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23823 {
23824         if (flags & NDR_IN) {
23825         }
23826         if (flags & NDR_OUT) {
23827                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23828         }
23829         return NDR_ERR_SUCCESS;
23830 }
23831
23832 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23833 {
23834         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23835         ndr->depth++;
23836         if (flags & NDR_SET_VALUES) {
23837                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23838         }
23839         if (flags & NDR_IN) {
23840                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23841                 ndr->depth++;
23842                 ndr->depth--;
23843         }
23844         if (flags & NDR_OUT) {
23845                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23846                 ndr->depth++;
23847                 ndr_print_WERROR(ndr, "result", r->out.result);
23848                 ndr->depth--;
23849         }
23850         ndr->depth--;
23851 }
23852
23853 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23854 {
23855         if (flags & NDR_IN) {
23856         }
23857         if (flags & NDR_OUT) {
23858                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23859         }
23860         return NDR_ERR_SUCCESS;
23861 }
23862
23863 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23864 {
23865         if (flags & NDR_IN) {
23866         }
23867         if (flags & NDR_OUT) {
23868                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23869         }
23870         return NDR_ERR_SUCCESS;
23871 }
23872
23873 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23874 {
23875         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23876         ndr->depth++;
23877         if (flags & NDR_SET_VALUES) {
23878                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23879         }
23880         if (flags & NDR_IN) {
23881                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23882                 ndr->depth++;
23883                 ndr->depth--;
23884         }
23885         if (flags & NDR_OUT) {
23886                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23887                 ndr->depth++;
23888                 ndr_print_WERROR(ndr, "result", r->out.result);
23889                 ndr->depth--;
23890         }
23891         ndr->depth--;
23892 }
23893
23894 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23895 {
23896         if (flags & NDR_IN) {
23897                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23898                 if (r->in.servername) {
23899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23900                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23901                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23902                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23903                 }
23904                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23905                 if (r->in.print_processor_name) {
23906                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23907                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23908                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23909                         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));
23910                 }
23911                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23912                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23913                 if (r->in.buffer) {
23914                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23915                 }
23916                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23917         }
23918         if (flags & NDR_OUT) {
23919                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23920                 if (r->out.info) {
23921                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23922                 }
23923                 if (r->out.needed == NULL) {
23924                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23925                 }
23926                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23927                 if (r->out.count == NULL) {
23928                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23929                 }
23930                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23931                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23932         }
23933         return NDR_ERR_SUCCESS;
23934 }
23935
23936 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23937 {
23938         uint32_t _ptr_servername;
23939         uint32_t _ptr_print_processor_name;
23940         uint32_t _ptr_buffer;
23941         uint32_t _ptr_info;
23942         TALLOC_CTX *_mem_save_servername_0;
23943         TALLOC_CTX *_mem_save_print_processor_name_0;
23944         TALLOC_CTX *_mem_save_buffer_0;
23945         TALLOC_CTX *_mem_save_info_0;
23946         TALLOC_CTX *_mem_save_needed_0;
23947         TALLOC_CTX *_mem_save_count_0;
23948         if (flags & NDR_IN) {
23949                 ZERO_STRUCT(r->out);
23950
23951                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23952                 if (_ptr_servername) {
23953                         NDR_PULL_ALLOC(ndr, r->in.servername);
23954                 } else {
23955                         r->in.servername = NULL;
23956                 }
23957                 if (r->in.servername) {
23958                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23959                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23960                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23961                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23962                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23963                                 return 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));
23964                         }
23965                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23966                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23967                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23968                 }
23969                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23970                 if (_ptr_print_processor_name) {
23971                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23972                 } else {
23973                         r->in.print_processor_name = NULL;
23974                 }
23975                 if (r->in.print_processor_name) {
23976                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23977                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23978                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23979                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23980                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23981                                 return 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));
23982                         }
23983                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23984                         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));
23985                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23986                 }
23987                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23988                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23989                 if (_ptr_buffer) {
23990                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23991                 } else {
23992                         r->in.buffer = NULL;
23993                 }
23994                 if (r->in.buffer) {
23995                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23996                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23997                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23998                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23999                 }
24000                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24001                 NDR_PULL_ALLOC(ndr, r->out.needed);
24002                 ZERO_STRUCTP(r->out.needed);
24003                 NDR_PULL_ALLOC(ndr, r->out.count);
24004                 ZERO_STRUCTP(r->out.count);
24005         }
24006         if (flags & NDR_OUT) {
24007                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24008                 if (_ptr_info) {
24009                         NDR_PULL_ALLOC(ndr, r->out.info);
24010                 } else {
24011                         r->out.info = NULL;
24012                 }
24013                 if (r->out.info) {
24014                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24015                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24016                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
24017                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24018                 }
24019                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24020                         NDR_PULL_ALLOC(ndr, r->out.needed);
24021                 }
24022                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24023                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24024                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24025                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24026                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24027                         NDR_PULL_ALLOC(ndr, r->out.count);
24028                 }
24029                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
24030                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
24031                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
24032                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
24033                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24034         }
24035         return NDR_ERR_SUCCESS;
24036 }
24037
24038 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
24039 {
24040         uint32_t cntr_info_0;
24041         if (flags & NDR_IN) {
24042                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24043                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
24044         }
24045         if (flags & NDR_OUT) {
24046                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24047                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24048                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24049                 }
24050                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24051                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24052                 }
24053         }
24054         return NDR_ERR_SUCCESS;
24055 }
24056
24057 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
24058 {
24059         uint32_t cntr_info_0;
24060         TALLOC_CTX *_mem_save_info_0;
24061         if (flags & NDR_IN) {
24062                 ZERO_STRUCT(r->out);
24063
24064                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24065                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
24066         }
24067         if (flags & NDR_OUT) {
24068                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
24069                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24070                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24071                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24072                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
24073                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
24074                 }
24075                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
24076                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
24077                 }
24078                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24079         }
24080         return NDR_ERR_SUCCESS;
24081 }
24082
24083 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
24084 {
24085         uint32_t cntr_info_2;
24086         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
24087         ndr->depth++;
24088         if (flags & NDR_SET_VALUES) {
24089                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24090         }
24091         if (flags & NDR_IN) {
24092                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
24093                 ndr->depth++;
24094                 ndr_print_ptr(ndr, "servername", r->in.servername);
24095                 ndr->depth++;
24096                 if (r->in.servername) {
24097                         ndr_print_string(ndr, "servername", r->in.servername);
24098                 }
24099                 ndr->depth--;
24100                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
24101                 ndr->depth++;
24102                 if (r->in.print_processor_name) {
24103                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
24104                 }
24105                 ndr->depth--;
24106                 ndr_print_uint32(ndr, "level", r->in.level);
24107                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24108                 ndr->depth++;
24109                 if (r->in.buffer) {
24110                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24111                 }
24112                 ndr->depth--;
24113                 ndr_print_uint32(ndr, "offered", r->in.offered);
24114                 ndr->depth--;
24115         }
24116         if (flags & NDR_OUT) {
24117                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
24118                 ndr->depth++;
24119                 ndr_print_ptr(ndr, "count", r->out.count);
24120                 ndr->depth++;
24121                 ndr_print_uint32(ndr, "count", *r->out.count);
24122                 ndr->depth--;
24123                 ndr_print_ptr(ndr, "info", r->out.info);
24124                 ndr->depth++;
24125                 ndr_print_ptr(ndr, "info", *r->out.info);
24126                 ndr->depth++;
24127                 if (*r->out.info) {
24128                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
24129                         ndr->depth++;
24130                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
24131                                 char *idx_2=NULL;
24132                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
24133                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
24134                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
24135                                         free(idx_2);
24136                                 }
24137                         }
24138                         ndr->depth--;
24139                 }
24140                 ndr->depth--;
24141                 ndr->depth--;
24142                 ndr_print_ptr(ndr, "needed", r->out.needed);
24143                 ndr->depth++;
24144                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24145                 ndr->depth--;
24146                 ndr_print_WERROR(ndr, "result", r->out.result);
24147                 ndr->depth--;
24148         }
24149         ndr->depth--;
24150 }
24151
24152 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
24153 {
24154         if (flags & NDR_IN) {
24155                 if (r->in.handle == NULL) {
24156                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24157                 }
24158                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24159                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
24160                 if (r->in.data_type) {
24161                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24162                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24163                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
24164                         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));
24165                 }
24166                 if (r->in.devmode_ctr == NULL) {
24167                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24168                 }
24169                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24170         }
24171         if (flags & NDR_OUT) {
24172                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24173         }
24174         return NDR_ERR_SUCCESS;
24175 }
24176
24177 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
24178 {
24179         uint32_t _ptr_data_type;
24180         TALLOC_CTX *_mem_save_handle_0;
24181         TALLOC_CTX *_mem_save_data_type_0;
24182         TALLOC_CTX *_mem_save_devmode_ctr_0;
24183         if (flags & NDR_IN) {
24184                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24185                         NDR_PULL_ALLOC(ndr, r->in.handle);
24186                 }
24187                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24188                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24189                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24190                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24191                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
24192                 if (_ptr_data_type) {
24193                         NDR_PULL_ALLOC(ndr, r->in.data_type);
24194                 } else {
24195                         r->in.data_type = NULL;
24196                 }
24197                 if (r->in.data_type) {
24198                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
24199                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
24200                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
24201                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
24202                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
24203                                 return 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));
24204                         }
24205                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
24206                         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));
24207                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
24208                 }
24209                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24210                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
24211                 }
24212                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
24213                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
24214                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
24215                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
24216         }
24217         if (flags & NDR_OUT) {
24218                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24219         }
24220         return NDR_ERR_SUCCESS;
24221 }
24222
24223 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
24224 {
24225         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
24226         ndr->depth++;
24227         if (flags & NDR_SET_VALUES) {
24228                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24229         }
24230         if (flags & NDR_IN) {
24231                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
24232                 ndr->depth++;
24233                 ndr_print_ptr(ndr, "handle", r->in.handle);
24234                 ndr->depth++;
24235                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24236                 ndr->depth--;
24237                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
24238                 ndr->depth++;
24239                 if (r->in.data_type) {
24240                         ndr_print_string(ndr, "data_type", r->in.data_type);
24241                 }
24242                 ndr->depth--;
24243                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
24244                 ndr->depth++;
24245                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
24246                 ndr->depth--;
24247                 ndr->depth--;
24248         }
24249         if (flags & NDR_OUT) {
24250                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
24251                 ndr->depth++;
24252                 ndr_print_WERROR(ndr, "result", r->out.result);
24253                 ndr->depth--;
24254         }
24255         ndr->depth--;
24256 }
24257
24258 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
24259 {
24260         if (flags & NDR_IN) {
24261                 if (r->in.handle == NULL) {
24262                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24263                 }
24264                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24265                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
24266                 if (r->in.architecture) {
24267                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24268                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24269                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24270                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24271                 }
24272                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24273                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24274                 if (r->in.buffer) {
24275                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24276                 }
24277                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
24279                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
24280         }
24281         if (flags & NDR_OUT) {
24282                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24283                 if (r->out.info) {
24284                         {
24285                                 struct ndr_push *_ndr_info;
24286                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24287                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24288                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24289                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24290                         }
24291                 }
24292                 if (r->out.needed == NULL) {
24293                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24294                 }
24295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24296                 if (r->out.server_major_version == NULL) {
24297                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24298                 }
24299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24300                 if (r->out.server_minor_version == NULL) {
24301                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24302                 }
24303                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24304                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24305         }
24306         return NDR_ERR_SUCCESS;
24307 }
24308
24309 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24310 {
24311         uint32_t _ptr_architecture;
24312         uint32_t _ptr_buffer;
24313         uint32_t _ptr_info;
24314         TALLOC_CTX *_mem_save_handle_0;
24315         TALLOC_CTX *_mem_save_architecture_0;
24316         TALLOC_CTX *_mem_save_buffer_0;
24317         TALLOC_CTX *_mem_save_info_0;
24318         TALLOC_CTX *_mem_save_needed_0;
24319         TALLOC_CTX *_mem_save_server_major_version_0;
24320         TALLOC_CTX *_mem_save_server_minor_version_0;
24321         if (flags & NDR_IN) {
24322                 ZERO_STRUCT(r->out);
24323
24324                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24325                         NDR_PULL_ALLOC(ndr, r->in.handle);
24326                 }
24327                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24328                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24329                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24330                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24331                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24332                 if (_ptr_architecture) {
24333                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24334                 } else {
24335                         r->in.architecture = NULL;
24336                 }
24337                 if (r->in.architecture) {
24338                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24339                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24340                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24341                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24342                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24343                                 return 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));
24344                         }
24345                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24346                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24347                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24348                 }
24349                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24350                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24351                 if (_ptr_buffer) {
24352                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24353                 } else {
24354                         r->in.buffer = NULL;
24355                 }
24356                 if (r->in.buffer) {
24357                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24358                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24359                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24360                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24361                 }
24362                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24363                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24364                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24365                 NDR_PULL_ALLOC(ndr, r->out.needed);
24366                 ZERO_STRUCTP(r->out.needed);
24367                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24368                 ZERO_STRUCTP(r->out.server_major_version);
24369                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24370                 ZERO_STRUCTP(r->out.server_minor_version);
24371         }
24372         if (flags & NDR_OUT) {
24373                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24374                 if (_ptr_info) {
24375                         NDR_PULL_ALLOC(ndr, r->out.info);
24376                 } else {
24377                         r->out.info = NULL;
24378                 }
24379                 if (r->out.info) {
24380                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24381                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24382                         {
24383                                 struct ndr_pull *_ndr_info;
24384                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24385                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24386                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24387                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24388                         }
24389                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24390                 }
24391                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24392                         NDR_PULL_ALLOC(ndr, r->out.needed);
24393                 }
24394                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24395                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24397                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24398                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24399                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24400                 }
24401                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24402                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24403                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24404                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24405                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24406                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24407                 }
24408                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24409                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24410                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24411                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24412                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24413         }
24414         return NDR_ERR_SUCCESS;
24415 }
24416
24417 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24418 {
24419         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24420         ndr->depth++;
24421         if (flags & NDR_SET_VALUES) {
24422                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24423         }
24424         if (flags & NDR_IN) {
24425                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24426                 ndr->depth++;
24427                 ndr_print_ptr(ndr, "handle", r->in.handle);
24428                 ndr->depth++;
24429                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24430                 ndr->depth--;
24431                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24432                 ndr->depth++;
24433                 if (r->in.architecture) {
24434                         ndr_print_string(ndr, "architecture", r->in.architecture);
24435                 }
24436                 ndr->depth--;
24437                 ndr_print_uint32(ndr, "level", r->in.level);
24438                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24439                 ndr->depth++;
24440                 if (r->in.buffer) {
24441                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24442                 }
24443                 ndr->depth--;
24444                 ndr_print_uint32(ndr, "offered", r->in.offered);
24445                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24446                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24447                 ndr->depth--;
24448         }
24449         if (flags & NDR_OUT) {
24450                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24451                 ndr->depth++;
24452                 ndr_print_ptr(ndr, "info", r->out.info);
24453                 ndr->depth++;
24454                 if (r->out.info) {
24455                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24456                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24457                 }
24458                 ndr->depth--;
24459                 ndr_print_ptr(ndr, "needed", r->out.needed);
24460                 ndr->depth++;
24461                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24462                 ndr->depth--;
24463                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24464                 ndr->depth++;
24465                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24466                 ndr->depth--;
24467                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24468                 ndr->depth++;
24469                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24470                 ndr->depth--;
24471                 ndr_print_WERROR(ndr, "result", r->out.result);
24472                 ndr->depth--;
24473         }
24474         ndr->depth--;
24475 }
24476
24477 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24478 {
24479         if (flags & NDR_IN) {
24480         }
24481         if (flags & NDR_OUT) {
24482                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24483         }
24484         return NDR_ERR_SUCCESS;
24485 }
24486
24487 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24488 {
24489         if (flags & NDR_IN) {
24490         }
24491         if (flags & NDR_OUT) {
24492                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24493         }
24494         return NDR_ERR_SUCCESS;
24495 }
24496
24497 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24498 {
24499         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24500         ndr->depth++;
24501         if (flags & NDR_SET_VALUES) {
24502                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24503         }
24504         if (flags & NDR_IN) {
24505                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24506                 ndr->depth++;
24507                 ndr->depth--;
24508         }
24509         if (flags & NDR_OUT) {
24510                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24511                 ndr->depth++;
24512                 ndr_print_WERROR(ndr, "result", r->out.result);
24513                 ndr->depth--;
24514         }
24515         ndr->depth--;
24516 }
24517
24518 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24519 {
24520         if (flags & NDR_IN) {
24521         }
24522         if (flags & NDR_OUT) {
24523                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24524         }
24525         return NDR_ERR_SUCCESS;
24526 }
24527
24528 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24529 {
24530         if (flags & NDR_IN) {
24531         }
24532         if (flags & NDR_OUT) {
24533                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24534         }
24535         return NDR_ERR_SUCCESS;
24536 }
24537
24538 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24539 {
24540         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24541         ndr->depth++;
24542         if (flags & NDR_SET_VALUES) {
24543                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24544         }
24545         if (flags & NDR_IN) {
24546                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24547                 ndr->depth++;
24548                 ndr->depth--;
24549         }
24550         if (flags & NDR_OUT) {
24551                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24552                 ndr->depth++;
24553                 ndr_print_WERROR(ndr, "result", r->out.result);
24554                 ndr->depth--;
24555         }
24556         ndr->depth--;
24557 }
24558
24559 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24560 {
24561         if (flags & NDR_IN) {
24562                 if (r->in.handle == NULL) {
24563                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24564                 }
24565                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24566         }
24567         if (flags & NDR_OUT) {
24568                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24569         }
24570         return NDR_ERR_SUCCESS;
24571 }
24572
24573 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24574 {
24575         TALLOC_CTX *_mem_save_handle_0;
24576         if (flags & NDR_IN) {
24577                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24578                         NDR_PULL_ALLOC(ndr, r->in.handle);
24579                 }
24580                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24581                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24582                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24584         }
24585         if (flags & NDR_OUT) {
24586                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24587         }
24588         return NDR_ERR_SUCCESS;
24589 }
24590
24591 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24592 {
24593         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24594         ndr->depth++;
24595         if (flags & NDR_SET_VALUES) {
24596                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24597         }
24598         if (flags & NDR_IN) {
24599                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24600                 ndr->depth++;
24601                 ndr_print_ptr(ndr, "handle", r->in.handle);
24602                 ndr->depth++;
24603                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24604                 ndr->depth--;
24605                 ndr->depth--;
24606         }
24607         if (flags & NDR_OUT) {
24608                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24609                 ndr->depth++;
24610                 ndr_print_WERROR(ndr, "result", r->out.result);
24611                 ndr->depth--;
24612         }
24613         ndr->depth--;
24614 }
24615
24616 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24617 {
24618         if (flags & NDR_IN) {
24619         }
24620         if (flags & NDR_OUT) {
24621                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24622         }
24623         return NDR_ERR_SUCCESS;
24624 }
24625
24626 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24627 {
24628         if (flags & NDR_IN) {
24629         }
24630         if (flags & NDR_OUT) {
24631                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24632         }
24633         return NDR_ERR_SUCCESS;
24634 }
24635
24636 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24637 {
24638         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24639         ndr->depth++;
24640         if (flags & NDR_SET_VALUES) {
24641                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24642         }
24643         if (flags & NDR_IN) {
24644                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24645                 ndr->depth++;
24646                 ndr->depth--;
24647         }
24648         if (flags & NDR_OUT) {
24649                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24650                 ndr->depth++;
24651                 ndr_print_WERROR(ndr, "result", r->out.result);
24652                 ndr->depth--;
24653         }
24654         ndr->depth--;
24655 }
24656
24657 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24658 {
24659         if (flags & NDR_IN) {
24660                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24662                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24663                 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));
24664                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24665                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24666                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24667                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24668                 if (r->in.buffer) {
24669                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24670                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24671                 }
24672         }
24673         if (flags & NDR_OUT) {
24674                 if (r->out.handle == NULL) {
24675                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24676                 }
24677                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24678                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24679         }
24680         return NDR_ERR_SUCCESS;
24681 }
24682
24683 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24684 {
24685         uint32_t _ptr_buffer;
24686         TALLOC_CTX *_mem_save_buffer_0;
24687         TALLOC_CTX *_mem_save_handle_0;
24688         if (flags & NDR_IN) {
24689                 ZERO_STRUCT(r->out);
24690
24691                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24692                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24693                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24694                         return 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));
24695                 }
24696                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24697                 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));
24698                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24699                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24700                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24701                 if (r->in.bufsize > 512) {
24702                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24703                 }
24704                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24705                 if (_ptr_buffer) {
24706                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24707                 } else {
24708                         r->in.buffer = NULL;
24709                 }
24710                 if (r->in.buffer) {
24711                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24712                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24713                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24714                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24715                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24717                 }
24718                 NDR_PULL_ALLOC(ndr, r->out.handle);
24719                 ZERO_STRUCTP(r->out.handle);
24720                 if (r->in.buffer) {
24721                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24722                 }
24723         }
24724         if (flags & NDR_OUT) {
24725                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24726                         NDR_PULL_ALLOC(ndr, r->out.handle);
24727                 }
24728                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24729                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24730                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24731                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24732                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24733         }
24734         return NDR_ERR_SUCCESS;
24735 }
24736
24737 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24738 {
24739         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24740         ndr->depth++;
24741         if (flags & NDR_SET_VALUES) {
24742                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24743         }
24744         if (flags & NDR_IN) {
24745                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24746                 ndr->depth++;
24747                 ndr_print_string(ndr, "server_name", r->in.server_name);
24748                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24749                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24750                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24751                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24752                 ndr->depth++;
24753                 if (r->in.buffer) {
24754                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24755                 }
24756                 ndr->depth--;
24757                 ndr->depth--;
24758         }
24759         if (flags & NDR_OUT) {
24760                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24761                 ndr->depth++;
24762                 ndr_print_ptr(ndr, "handle", r->out.handle);
24763                 ndr->depth++;
24764                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24765                 ndr->depth--;
24766                 ndr_print_WERROR(ndr, "result", r->out.result);
24767                 ndr->depth--;
24768         }
24769         ndr->depth--;
24770 }
24771
24772 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24773 {
24774         if (flags & NDR_IN) {
24775                 if (r->in.handle == NULL) {
24776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24777                 }
24778                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24779                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24780                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24782                 if (r->in.buffer) {
24783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24784                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24785                 }
24786         }
24787         if (flags & NDR_OUT) {
24788                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24789         }
24790         return NDR_ERR_SUCCESS;
24791 }
24792
24793 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24794 {
24795         uint32_t _ptr_buffer;
24796         TALLOC_CTX *_mem_save_handle_0;
24797         TALLOC_CTX *_mem_save_buffer_0;
24798         if (flags & NDR_IN) {
24799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24800                         NDR_PULL_ALLOC(ndr, r->in.handle);
24801                 }
24802                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24804                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24806                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24807                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24808                 if (r->in.bufsize > 512) {
24809                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24810                 }
24811                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24812                 if (_ptr_buffer) {
24813                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24814                 } else {
24815                         r->in.buffer = NULL;
24816                 }
24817                 if (r->in.buffer) {
24818                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24819                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24820                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24821                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24822                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24823                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24824                 }
24825                 if (r->in.buffer) {
24826                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24827                 }
24828         }
24829         if (flags & NDR_OUT) {
24830                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24831         }
24832         return NDR_ERR_SUCCESS;
24833 }
24834
24835 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24836 {
24837         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24838         ndr->depth++;
24839         if (flags & NDR_SET_VALUES) {
24840                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24841         }
24842         if (flags & NDR_IN) {
24843                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24844                 ndr->depth++;
24845                 ndr_print_ptr(ndr, "handle", r->in.handle);
24846                 ndr->depth++;
24847                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24848                 ndr->depth--;
24849                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24850                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24851                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24852                 ndr->depth++;
24853                 if (r->in.buffer) {
24854                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24855                 }
24856                 ndr->depth--;
24857                 ndr->depth--;
24858         }
24859         if (flags & NDR_OUT) {
24860                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24861                 ndr->depth++;
24862                 ndr_print_WERROR(ndr, "result", r->out.result);
24863                 ndr->depth--;
24864         }
24865         ndr->depth--;
24866 }
24867
24868 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24869 {
24870         if (flags & NDR_IN) {
24871                 if (r->in.handle == NULL) {
24872                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24873                 }
24874                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24875         }
24876         if (flags & NDR_OUT) {
24877                 if (r->out.handle == NULL) {
24878                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24879                 }
24880                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24881                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24882         }
24883         return NDR_ERR_SUCCESS;
24884 }
24885
24886 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24887 {
24888         TALLOC_CTX *_mem_save_handle_0;
24889         if (flags & NDR_IN) {
24890                 ZERO_STRUCT(r->out);
24891
24892                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24893                         NDR_PULL_ALLOC(ndr, r->in.handle);
24894                 }
24895                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24896                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24897                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24898                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24899                 NDR_PULL_ALLOC(ndr, r->out.handle);
24900                 *r->out.handle = *r->in.handle;
24901         }
24902         if (flags & NDR_OUT) {
24903                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24904                         NDR_PULL_ALLOC(ndr, r->out.handle);
24905                 }
24906                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24907                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24908                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24909                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24910                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24911         }
24912         return NDR_ERR_SUCCESS;
24913 }
24914
24915 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24916 {
24917         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24918         ndr->depth++;
24919         if (flags & NDR_SET_VALUES) {
24920                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24921         }
24922         if (flags & NDR_IN) {
24923                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24924                 ndr->depth++;
24925                 ndr_print_ptr(ndr, "handle", r->in.handle);
24926                 ndr->depth++;
24927                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24928                 ndr->depth--;
24929                 ndr->depth--;
24930         }
24931         if (flags & NDR_OUT) {
24932                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24933                 ndr->depth++;
24934                 ndr_print_ptr(ndr, "handle", r->out.handle);
24935                 ndr->depth++;
24936                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24937                 ndr->depth--;
24938                 ndr_print_WERROR(ndr, "result", r->out.result);
24939                 ndr->depth--;
24940         }
24941         ndr->depth--;
24942 }
24943
24944 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24945 {
24946         if (flags & NDR_IN) {
24947         }
24948         if (flags & NDR_OUT) {
24949                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24950         }
24951         return NDR_ERR_SUCCESS;
24952 }
24953
24954 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24955 {
24956         if (flags & NDR_IN) {
24957         }
24958         if (flags & NDR_OUT) {
24959                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24960         }
24961         return NDR_ERR_SUCCESS;
24962 }
24963
24964 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24965 {
24966         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24967         ndr->depth++;
24968         if (flags & NDR_SET_VALUES) {
24969                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24970         }
24971         if (flags & NDR_IN) {
24972                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24973                 ndr->depth++;
24974                 ndr->depth--;
24975         }
24976         if (flags & NDR_OUT) {
24977                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24978                 ndr->depth++;
24979                 ndr_print_WERROR(ndr, "result", r->out.result);
24980                 ndr->depth--;
24981         }
24982         ndr->depth--;
24983 }
24984
24985 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24986 {
24987         if (flags & NDR_IN) {
24988         }
24989         if (flags & NDR_OUT) {
24990                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24991         }
24992         return NDR_ERR_SUCCESS;
24993 }
24994
24995 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24996 {
24997         if (flags & NDR_IN) {
24998         }
24999         if (flags & NDR_OUT) {
25000                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25001         }
25002         return NDR_ERR_SUCCESS;
25003 }
25004
25005 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
25006 {
25007         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
25008         ndr->depth++;
25009         if (flags & NDR_SET_VALUES) {
25010                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25011         }
25012         if (flags & NDR_IN) {
25013                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
25014                 ndr->depth++;
25015                 ndr->depth--;
25016         }
25017         if (flags & NDR_OUT) {
25018                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
25019                 ndr->depth++;
25020                 ndr_print_WERROR(ndr, "result", r->out.result);
25021                 ndr->depth--;
25022         }
25023         ndr->depth--;
25024 }
25025
25026 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
25027 {
25028         if (flags & NDR_IN) {
25029         }
25030         if (flags & NDR_OUT) {
25031                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25032         }
25033         return NDR_ERR_SUCCESS;
25034 }
25035
25036 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
25037 {
25038         if (flags & NDR_IN) {
25039         }
25040         if (flags & NDR_OUT) {
25041                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25042         }
25043         return NDR_ERR_SUCCESS;
25044 }
25045
25046 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
25047 {
25048         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
25049         ndr->depth++;
25050         if (flags & NDR_SET_VALUES) {
25051                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25052         }
25053         if (flags & NDR_IN) {
25054                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
25055                 ndr->depth++;
25056                 ndr->depth--;
25057         }
25058         if (flags & NDR_OUT) {
25059                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
25060                 ndr->depth++;
25061                 ndr_print_WERROR(ndr, "result", r->out.result);
25062                 ndr->depth--;
25063         }
25064         ndr->depth--;
25065 }
25066
25067 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
25068 {
25069         if (flags & NDR_IN) {
25070         }
25071         if (flags & NDR_OUT) {
25072                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25073         }
25074         return NDR_ERR_SUCCESS;
25075 }
25076
25077 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
25078 {
25079         if (flags & NDR_IN) {
25080         }
25081         if (flags & NDR_OUT) {
25082                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25083         }
25084         return NDR_ERR_SUCCESS;
25085 }
25086
25087 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
25088 {
25089         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
25090         ndr->depth++;
25091         if (flags & NDR_SET_VALUES) {
25092                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25093         }
25094         if (flags & NDR_IN) {
25095                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
25096                 ndr->depth++;
25097                 ndr->depth--;
25098         }
25099         if (flags & NDR_OUT) {
25100                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
25101                 ndr->depth++;
25102                 ndr_print_WERROR(ndr, "result", r->out.result);
25103                 ndr->depth--;
25104         }
25105         ndr->depth--;
25106 }
25107
25108 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25109 {
25110         if (flags & NDR_IN) {
25111                 if (r->in.handle == NULL) {
25112                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25113                 }
25114                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25115                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
25117                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
25118                 if (r->in.local_machine) {
25119                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25120                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25121                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
25122                         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));
25123                 }
25124                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
25125                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
25126                 if (r->in.notify_options) {
25127                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25128                 }
25129         }
25130         if (flags & NDR_OUT) {
25131                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25132         }
25133         return NDR_ERR_SUCCESS;
25134 }
25135
25136 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25137 {
25138         uint32_t _ptr_local_machine;
25139         uint32_t _ptr_notify_options;
25140         TALLOC_CTX *_mem_save_handle_0;
25141         TALLOC_CTX *_mem_save_local_machine_0;
25142         TALLOC_CTX *_mem_save_notify_options_0;
25143         if (flags & NDR_IN) {
25144                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25145                         NDR_PULL_ALLOC(ndr, r->in.handle);
25146                 }
25147                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25148                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25149                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25150                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25151                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25152                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
25153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
25154                 if (_ptr_local_machine) {
25155                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
25156                 } else {
25157                         r->in.local_machine = NULL;
25158                 }
25159                 if (r->in.local_machine) {
25160                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
25161                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
25162                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
25163                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
25164                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
25165                                 return 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));
25166                         }
25167                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
25168                         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));
25169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
25170                 }
25171                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
25172                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
25173                 if (_ptr_notify_options) {
25174                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
25175                 } else {
25176                         r->in.notify_options = NULL;
25177                 }
25178                 if (r->in.notify_options) {
25179                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25180                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
25181                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
25182                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
25183                 }
25184         }
25185         if (flags & NDR_OUT) {
25186                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25187         }
25188         return NDR_ERR_SUCCESS;
25189 }
25190
25191 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
25192 {
25193         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25194         ndr->depth++;
25195         if (flags & NDR_SET_VALUES) {
25196                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25197         }
25198         if (flags & NDR_IN) {
25199                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25200                 ndr->depth++;
25201                 ndr_print_ptr(ndr, "handle", r->in.handle);
25202                 ndr->depth++;
25203                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25204                 ndr->depth--;
25205                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25206                 ndr_print_uint32(ndr, "options", r->in.options);
25207                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
25208                 ndr->depth++;
25209                 if (r->in.local_machine) {
25210                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
25211                 }
25212                 ndr->depth--;
25213                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
25214                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
25215                 ndr->depth++;
25216                 if (r->in.notify_options) {
25217                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
25218                 }
25219                 ndr->depth--;
25220                 ndr->depth--;
25221         }
25222         if (flags & NDR_OUT) {
25223                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
25224                 ndr->depth++;
25225                 ndr_print_WERROR(ndr, "result", r->out.result);
25226                 ndr->depth--;
25227         }
25228         ndr->depth--;
25229 }
25230
25231 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25232 {
25233         if (flags & NDR_IN) {
25234                 if (r->in.handle == NULL) {
25235                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25236                 }
25237                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25238                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
25239                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
25240                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
25241                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25242                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25243         }
25244         if (flags & NDR_OUT) {
25245                 if (r->out.reply_result == NULL) {
25246                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25247                 }
25248                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
25249                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25250         }
25251         return NDR_ERR_SUCCESS;
25252 }
25253
25254 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
25255 {
25256         TALLOC_CTX *_mem_save_handle_0;
25257         TALLOC_CTX *_mem_save_reply_result_0;
25258         if (flags & NDR_IN) {
25259                 ZERO_STRUCT(r->out);
25260
25261                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25262                         NDR_PULL_ALLOC(ndr, r->in.handle);
25263                 }
25264                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25265                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25266                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25267                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25268                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
25269                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25270                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
25271                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25272                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25273                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
25274                 ZERO_STRUCTP(r->out.reply_result);
25275         }
25276         if (flags & NDR_OUT) {
25277                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25278                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
25279                 }
25280                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
25281                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
25282                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
25283                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
25284                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25285         }
25286         return NDR_ERR_SUCCESS;
25287 }
25288
25289 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25290 {
25291         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
25292         ndr->depth++;
25293         if (flags & NDR_SET_VALUES) {
25294                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25295         }
25296         if (flags & NDR_IN) {
25297                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25298                 ndr->depth++;
25299                 ndr_print_ptr(ndr, "handle", r->in.handle);
25300                 ndr->depth++;
25301                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25302                 ndr->depth--;
25303                 ndr_print_uint32(ndr, "color", r->in.color);
25304                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25305                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25306                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25307                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25308                 ndr->depth--;
25309         }
25310         if (flags & NDR_OUT) {
25311                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25312                 ndr->depth++;
25313                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25314                 ndr->depth++;
25315                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25316                 ndr->depth--;
25317                 ndr_print_WERROR(ndr, "result", r->out.result);
25318                 ndr->depth--;
25319         }
25320         ndr->depth--;
25321 }
25322
25323 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25324 {
25325         if (flags & NDR_IN) {
25326                 if (r->in.handle == NULL) {
25327                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25328                 }
25329                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25330                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25331                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25332                 if (r->in.options) {
25333                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25334                 }
25335         }
25336         if (flags & NDR_OUT) {
25337                 if (r->out.info == NULL) {
25338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25339                 }
25340                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25341                 if (*r->out.info) {
25342                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25343                 }
25344                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25345         }
25346         return NDR_ERR_SUCCESS;
25347 }
25348
25349 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25350 {
25351         uint32_t _ptr_options;
25352         uint32_t _ptr_info;
25353         TALLOC_CTX *_mem_save_handle_0;
25354         TALLOC_CTX *_mem_save_options_0;
25355         TALLOC_CTX *_mem_save_info_0;
25356         TALLOC_CTX *_mem_save_info_1;
25357         if (flags & NDR_IN) {
25358                 ZERO_STRUCT(r->out);
25359
25360                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25361                         NDR_PULL_ALLOC(ndr, r->in.handle);
25362                 }
25363                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25364                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25365                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25366                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25367                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25368                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25369                 if (_ptr_options) {
25370                         NDR_PULL_ALLOC(ndr, r->in.options);
25371                 } else {
25372                         r->in.options = NULL;
25373                 }
25374                 if (r->in.options) {
25375                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25376                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25377                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25378                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25379                 }
25380                 NDR_PULL_ALLOC(ndr, r->out.info);
25381                 ZERO_STRUCTP(r->out.info);
25382         }
25383         if (flags & NDR_OUT) {
25384                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25385                         NDR_PULL_ALLOC(ndr, r->out.info);
25386                 }
25387                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25388                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25389                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25390                 if (_ptr_info) {
25391                         NDR_PULL_ALLOC(ndr, *r->out.info);
25392                 } else {
25393                         *r->out.info = NULL;
25394                 }
25395                 if (*r->out.info) {
25396                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25397                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25398                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25399                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25400                 }
25401                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25402                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25403         }
25404         return NDR_ERR_SUCCESS;
25405 }
25406
25407 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25408 {
25409         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25410         ndr->depth++;
25411         if (flags & NDR_SET_VALUES) {
25412                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25413         }
25414         if (flags & NDR_IN) {
25415                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25416                 ndr->depth++;
25417                 ndr_print_ptr(ndr, "handle", r->in.handle);
25418                 ndr->depth++;
25419                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25420                 ndr->depth--;
25421                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25422                 ndr_print_ptr(ndr, "options", r->in.options);
25423                 ndr->depth++;
25424                 if (r->in.options) {
25425                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25426                 }
25427                 ndr->depth--;
25428                 ndr->depth--;
25429         }
25430         if (flags & NDR_OUT) {
25431                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25432                 ndr->depth++;
25433                 ndr_print_ptr(ndr, "info", r->out.info);
25434                 ndr->depth++;
25435                 ndr_print_ptr(ndr, "info", *r->out.info);
25436                 ndr->depth++;
25437                 if (*r->out.info) {
25438                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25439                 }
25440                 ndr->depth--;
25441                 ndr->depth--;
25442                 ndr_print_WERROR(ndr, "result", r->out.result);
25443                 ndr->depth--;
25444         }
25445         ndr->depth--;
25446 }
25447
25448 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25449 {
25450         if (flags & NDR_IN) {
25451         }
25452         if (flags & NDR_OUT) {
25453                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25454         }
25455         return NDR_ERR_SUCCESS;
25456 }
25457
25458 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25459 {
25460         if (flags & NDR_IN) {
25461         }
25462         if (flags & NDR_OUT) {
25463                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25464         }
25465         return NDR_ERR_SUCCESS;
25466 }
25467
25468 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25469 {
25470         ndr_print_struct(ndr, name, "spoolss_44");
25471         ndr->depth++;
25472         if (flags & NDR_SET_VALUES) {
25473                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25474         }
25475         if (flags & NDR_IN) {
25476                 ndr_print_struct(ndr, "in", "spoolss_44");
25477                 ndr->depth++;
25478                 ndr->depth--;
25479         }
25480         if (flags & NDR_OUT) {
25481                 ndr_print_struct(ndr, "out", "spoolss_44");
25482                 ndr->depth++;
25483                 ndr_print_WERROR(ndr, "result", r->out.result);
25484                 ndr->depth--;
25485         }
25486         ndr->depth--;
25487 }
25488
25489 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25490 {
25491         if (flags & NDR_IN) {
25492                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25493                 if (r->in.printername) {
25494                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25495                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25496                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25497                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25498                 }
25499                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25500                 if (r->in.datatype) {
25501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25502                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25503                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25504                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25505                 }
25506                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25507                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25508                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25509                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25510                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25511         }
25512         if (flags & NDR_OUT) {
25513                 if (r->out.handle == NULL) {
25514                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25515                 }
25516                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25517                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25518         }
25519         return NDR_ERR_SUCCESS;
25520 }
25521
25522 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25523 {
25524         uint32_t _ptr_printername;
25525         uint32_t _ptr_datatype;
25526         TALLOC_CTX *_mem_save_printername_0;
25527         TALLOC_CTX *_mem_save_datatype_0;
25528         TALLOC_CTX *_mem_save_handle_0;
25529         if (flags & NDR_IN) {
25530                 ZERO_STRUCT(r->out);
25531
25532                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25533                 if (_ptr_printername) {
25534                         NDR_PULL_ALLOC(ndr, r->in.printername);
25535                 } else {
25536                         r->in.printername = NULL;
25537                 }
25538                 if (r->in.printername) {
25539                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25540                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25541                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25542                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25543                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25544                                 return 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));
25545                         }
25546                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25547                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25548                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25549                 }
25550                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25551                 if (_ptr_datatype) {
25552                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25553                 } else {
25554                         r->in.datatype = NULL;
25555                 }
25556                 if (r->in.datatype) {
25557                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25558                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25559                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25560                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25561                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25562                                 return 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));
25563                         }
25564                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25565                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25567                 }
25568                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25569                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25570                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25571                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25572                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25573                 NDR_PULL_ALLOC(ndr, r->out.handle);
25574                 ZERO_STRUCTP(r->out.handle);
25575         }
25576         if (flags & NDR_OUT) {
25577                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25578                         NDR_PULL_ALLOC(ndr, r->out.handle);
25579                 }
25580                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25581                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25582                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25583                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25584                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25585         }
25586         return NDR_ERR_SUCCESS;
25587 }
25588
25589 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25590 {
25591         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25592         ndr->depth++;
25593         if (flags & NDR_SET_VALUES) {
25594                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25595         }
25596         if (flags & NDR_IN) {
25597                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25598                 ndr->depth++;
25599                 ndr_print_ptr(ndr, "printername", r->in.printername);
25600                 ndr->depth++;
25601                 if (r->in.printername) {
25602                         ndr_print_string(ndr, "printername", r->in.printername);
25603                 }
25604                 ndr->depth--;
25605                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25606                 ndr->depth++;
25607                 if (r->in.datatype) {
25608                         ndr_print_string(ndr, "datatype", r->in.datatype);
25609                 }
25610                 ndr->depth--;
25611                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25612                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25613                 ndr_print_uint32(ndr, "level", r->in.level);
25614                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25615                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25616                 ndr->depth--;
25617         }
25618         if (flags & NDR_OUT) {
25619                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25620                 ndr->depth++;
25621                 ndr_print_ptr(ndr, "handle", r->out.handle);
25622                 ndr->depth++;
25623                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25624                 ndr->depth--;
25625                 ndr_print_WERROR(ndr, "result", r->out.result);
25626                 ndr->depth--;
25627         }
25628         ndr->depth--;
25629 }
25630
25631 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25632 {
25633         if (flags & NDR_IN) {
25634                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25635                 if (r->in.server) {
25636                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25639                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25640                 }
25641                 if (r->in.info_ctr == NULL) {
25642                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25643                 }
25644                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25645                 if (r->in.devmode_ctr == NULL) {
25646                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25647                 }
25648                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25649                 if (r->in.secdesc_ctr == NULL) {
25650                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25651                 }
25652                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25653                 if (r->in.userlevel_ctr == NULL) {
25654                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25655                 }
25656                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25657         }
25658         if (flags & NDR_OUT) {
25659                 if (r->out.handle == NULL) {
25660                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25661                 }
25662                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25663                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25664         }
25665         return NDR_ERR_SUCCESS;
25666 }
25667
25668 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25669 {
25670         uint32_t _ptr_server;
25671         TALLOC_CTX *_mem_save_server_0;
25672         TALLOC_CTX *_mem_save_info_ctr_0;
25673         TALLOC_CTX *_mem_save_devmode_ctr_0;
25674         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25675         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25676         TALLOC_CTX *_mem_save_handle_0;
25677         if (flags & NDR_IN) {
25678                 ZERO_STRUCT(r->out);
25679
25680                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25681                 if (_ptr_server) {
25682                         NDR_PULL_ALLOC(ndr, r->in.server);
25683                 } else {
25684                         r->in.server = NULL;
25685                 }
25686                 if (r->in.server) {
25687                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25688                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25689                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25690                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25691                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25692                                 return 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));
25693                         }
25694                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25695                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25696                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25697                 }
25698                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25699                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25700                 }
25701                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25702                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25703                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25704                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25705                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25706                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25707                 }
25708                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25709                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25710                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25711                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25712                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25713                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25714                 }
25715                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25716                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25717                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25718                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25719                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25720                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25721                 }
25722                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25723                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25724                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25725                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25726                 NDR_PULL_ALLOC(ndr, r->out.handle);
25727                 ZERO_STRUCTP(r->out.handle);
25728         }
25729         if (flags & NDR_OUT) {
25730                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25731                         NDR_PULL_ALLOC(ndr, r->out.handle);
25732                 }
25733                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25734                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25735                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25736                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25737                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25738         }
25739         return NDR_ERR_SUCCESS;
25740 }
25741
25742 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25743 {
25744         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25745         ndr->depth++;
25746         if (flags & NDR_SET_VALUES) {
25747                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25748         }
25749         if (flags & NDR_IN) {
25750                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25751                 ndr->depth++;
25752                 ndr_print_ptr(ndr, "server", r->in.server);
25753                 ndr->depth++;
25754                 if (r->in.server) {
25755                         ndr_print_string(ndr, "server", r->in.server);
25756                 }
25757                 ndr->depth--;
25758                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25759                 ndr->depth++;
25760                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25761                 ndr->depth--;
25762                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25763                 ndr->depth++;
25764                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25765                 ndr->depth--;
25766                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25767                 ndr->depth++;
25768                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25769                 ndr->depth--;
25770                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25771                 ndr->depth++;
25772                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25773                 ndr->depth--;
25774                 ndr->depth--;
25775         }
25776         if (flags & NDR_OUT) {
25777                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25778                 ndr->depth++;
25779                 ndr_print_ptr(ndr, "handle", r->out.handle);
25780                 ndr->depth++;
25781                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25782                 ndr->depth--;
25783                 ndr_print_WERROR(ndr, "result", r->out.result);
25784                 ndr->depth--;
25785         }
25786         ndr->depth--;
25787 }
25788
25789 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25790 {
25791         if (flags & NDR_IN) {
25792         }
25793         if (flags & NDR_OUT) {
25794                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25795         }
25796         return NDR_ERR_SUCCESS;
25797 }
25798
25799 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25800 {
25801         if (flags & NDR_IN) {
25802         }
25803         if (flags & NDR_OUT) {
25804                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25805         }
25806         return NDR_ERR_SUCCESS;
25807 }
25808
25809 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25810 {
25811         ndr_print_struct(ndr, name, "spoolss_47");
25812         ndr->depth++;
25813         if (flags & NDR_SET_VALUES) {
25814                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25815         }
25816         if (flags & NDR_IN) {
25817                 ndr_print_struct(ndr, "in", "spoolss_47");
25818                 ndr->depth++;
25819                 ndr->depth--;
25820         }
25821         if (flags & NDR_OUT) {
25822                 ndr_print_struct(ndr, "out", "spoolss_47");
25823                 ndr->depth++;
25824                 ndr_print_WERROR(ndr, "result", r->out.result);
25825                 ndr->depth--;
25826         }
25827         ndr->depth--;
25828 }
25829
25830 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25831 {
25832         if (flags & NDR_IN) {
25833                 if (r->in.handle == NULL) {
25834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25835                 }
25836                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25840         }
25841         if (flags & NDR_OUT) {
25842                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25843                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25844                 if (r->out.value_needed == NULL) {
25845                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25846                 }
25847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25848                 if (r->out.type == NULL) {
25849                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25850                 }
25851                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
25852                 {
25853                         uint32_t _flags_save_uint8 = ndr->flags;
25854                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25855                         if (r->out.data == NULL) {
25856                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25857                         }
25858                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25859                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
25860                         ndr->flags = _flags_save_uint8;
25861                 }
25862                 if (r->out.data_needed == NULL) {
25863                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25864                 }
25865                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25866                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25867         }
25868         return NDR_ERR_SUCCESS;
25869 }
25870
25871 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25872 {
25873         TALLOC_CTX *_mem_save_handle_0;
25874         TALLOC_CTX *_mem_save_value_needed_0;
25875         TALLOC_CTX *_mem_save_type_0;
25876         TALLOC_CTX *_mem_save_data_needed_0;
25877         if (flags & NDR_IN) {
25878                 ZERO_STRUCT(r->out);
25879
25880                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25881                         NDR_PULL_ALLOC(ndr, r->in.handle);
25882                 }
25883                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25884                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25885                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25886                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25889                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25890                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25891                 ZERO_STRUCTP(r->out.value_needed);
25892                 NDR_PULL_ALLOC(ndr, r->out.type);
25893                 ZERO_STRUCTP(r->out.type);
25894                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
25895                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
25896                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25897                 ZERO_STRUCTP(r->out.data_needed);
25898         }
25899         if (flags & NDR_OUT) {
25900                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25901                 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));
25902                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25903                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25904                 }
25905                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25906                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25907                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25908                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25909                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25910                         NDR_PULL_ALLOC(ndr, r->out.type);
25911                 }
25912                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25913                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
25914                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
25915                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
25916                 {
25917                         uint32_t _flags_save_uint8 = ndr->flags;
25918                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25919                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
25920                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25921                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
25922                         }
25923                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
25924                         ndr->flags = _flags_save_uint8;
25925                 }
25926                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25927                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25928                 }
25929                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25930                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25931                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25932                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25933                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25934                 if (r->out.value_name) {
25935                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25936                 }
25937                 if (r->out.data) {
25938                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
25939                 }
25940         }
25941         return NDR_ERR_SUCCESS;
25942 }
25943
25944 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25945 {
25946         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25947         ndr->depth++;
25948         if (flags & NDR_SET_VALUES) {
25949                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25950         }
25951         if (flags & NDR_IN) {
25952                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25953                 ndr->depth++;
25954                 ndr_print_ptr(ndr, "handle", r->in.handle);
25955                 ndr->depth++;
25956                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25957                 ndr->depth--;
25958                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25959                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25960                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25961                 ndr->depth--;
25962         }
25963         if (flags & NDR_OUT) {
25964                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25965                 ndr->depth++;
25966                 ndr_print_string(ndr, "value_name", r->out.value_name);
25967                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25968                 ndr->depth++;
25969                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25970                 ndr->depth--;
25971                 ndr_print_ptr(ndr, "type", r->out.type);
25972                 ndr->depth++;
25973                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
25974                 ndr->depth--;
25975                 ndr_print_ptr(ndr, "data", r->out.data);
25976                 ndr->depth++;
25977                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
25978                 ndr->depth--;
25979                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25980                 ndr->depth++;
25981                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25982                 ndr->depth--;
25983                 ndr_print_WERROR(ndr, "result", r->out.result);
25984                 ndr->depth--;
25985         }
25986         ndr->depth--;
25987 }
25988
25989 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25990 {
25991         if (flags & NDR_IN) {
25992                 if (r->in.handle == NULL) {
25993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25994                 }
25995                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25996                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25997                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25998                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25999                 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));
26000         }
26001         if (flags & NDR_OUT) {
26002                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26003         }
26004         return NDR_ERR_SUCCESS;
26005 }
26006
26007 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
26008 {
26009         TALLOC_CTX *_mem_save_handle_0;
26010         if (flags & NDR_IN) {
26011                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26012                         NDR_PULL_ALLOC(ndr, r->in.handle);
26013                 }
26014                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26015                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26016                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26017                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26018                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26019                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26020                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26021                         return 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));
26022                 }
26023                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26024                 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));
26025         }
26026         if (flags & NDR_OUT) {
26027                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26028         }
26029         return NDR_ERR_SUCCESS;
26030 }
26031
26032 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
26033 {
26034         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
26035         ndr->depth++;
26036         if (flags & NDR_SET_VALUES) {
26037                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26038         }
26039         if (flags & NDR_IN) {
26040                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
26041                 ndr->depth++;
26042                 ndr_print_ptr(ndr, "handle", r->in.handle);
26043                 ndr->depth++;
26044                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26045                 ndr->depth--;
26046                 ndr_print_string(ndr, "value_name", r->in.value_name);
26047                 ndr->depth--;
26048         }
26049         if (flags & NDR_OUT) {
26050                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
26051                 ndr->depth++;
26052                 ndr_print_WERROR(ndr, "result", r->out.result);
26053                 ndr->depth--;
26054         }
26055         ndr->depth--;
26056 }
26057
26058 static enum ndr_err_code ndr_push_spoolss_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *r)
26059 {
26060         if (flags & NDR_IN) {
26061         }
26062         if (flags & NDR_OUT) {
26063                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26064         }
26065         return NDR_ERR_SUCCESS;
26066 }
26067
26068 static enum ndr_err_code ndr_pull_spoolss_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *r)
26069 {
26070         if (flags & NDR_IN) {
26071         }
26072         if (flags & NDR_OUT) {
26073                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26074         }
26075         return NDR_ERR_SUCCESS;
26076 }
26077
26078 _PUBLIC_ void ndr_print_spoolss_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
26079 {
26080         ndr_print_struct(ndr, name, "spoolss_4a");
26081         ndr->depth++;
26082         if (flags & NDR_SET_VALUES) {
26083                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26084         }
26085         if (flags & NDR_IN) {
26086                 ndr_print_struct(ndr, "in", "spoolss_4a");
26087                 ndr->depth++;
26088                 ndr->depth--;
26089         }
26090         if (flags & NDR_OUT) {
26091                 ndr_print_struct(ndr, "out", "spoolss_4a");
26092                 ndr->depth++;
26093                 ndr_print_WERROR(ndr, "result", r->out.result);
26094                 ndr->depth--;
26095         }
26096         ndr->depth--;
26097 }
26098
26099 static enum ndr_err_code ndr_push_spoolss_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
26100 {
26101         if (flags & NDR_IN) {
26102         }
26103         if (flags & NDR_OUT) {
26104                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26105         }
26106         return NDR_ERR_SUCCESS;
26107 }
26108
26109 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
26110 {
26111         if (flags & NDR_IN) {
26112         }
26113         if (flags & NDR_OUT) {
26114                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26115         }
26116         return NDR_ERR_SUCCESS;
26117 }
26118
26119 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
26120 {
26121         ndr_print_struct(ndr, name, "spoolss_4b");
26122         ndr->depth++;
26123         if (flags & NDR_SET_VALUES) {
26124                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26125         }
26126         if (flags & NDR_IN) {
26127                 ndr_print_struct(ndr, "in", "spoolss_4b");
26128                 ndr->depth++;
26129                 ndr->depth--;
26130         }
26131         if (flags & NDR_OUT) {
26132                 ndr_print_struct(ndr, "out", "spoolss_4b");
26133                 ndr->depth++;
26134                 ndr_print_WERROR(ndr, "result", r->out.result);
26135                 ndr->depth--;
26136         }
26137         ndr->depth--;
26138 }
26139
26140 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
26141 {
26142         if (flags & NDR_IN) {
26143         }
26144         if (flags & NDR_OUT) {
26145                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26146         }
26147         return NDR_ERR_SUCCESS;
26148 }
26149
26150 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
26151 {
26152         if (flags & NDR_IN) {
26153         }
26154         if (flags & NDR_OUT) {
26155                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26156         }
26157         return NDR_ERR_SUCCESS;
26158 }
26159
26160 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
26161 {
26162         ndr_print_struct(ndr, name, "spoolss_4c");
26163         ndr->depth++;
26164         if (flags & NDR_SET_VALUES) {
26165                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26166         }
26167         if (flags & NDR_IN) {
26168                 ndr_print_struct(ndr, "in", "spoolss_4c");
26169                 ndr->depth++;
26170                 ndr->depth--;
26171         }
26172         if (flags & NDR_OUT) {
26173                 ndr_print_struct(ndr, "out", "spoolss_4c");
26174                 ndr->depth++;
26175                 ndr_print_WERROR(ndr, "result", r->out.result);
26176                 ndr->depth--;
26177         }
26178         ndr->depth--;
26179 }
26180
26181 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
26182 {
26183         if (flags & NDR_IN) {
26184                 if (r->in.handle == NULL) {
26185                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26186                 }
26187                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26188                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26189                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26191                 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));
26192                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26193                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26194                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26195                 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));
26196                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
26197                 if (r->in.buffer == NULL) {
26198                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26199                 }
26200                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26201                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
26202                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26203         }
26204         if (flags & NDR_OUT) {
26205                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26206         }
26207         return NDR_ERR_SUCCESS;
26208 }
26209
26210 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
26211 {
26212         TALLOC_CTX *_mem_save_handle_0;
26213         if (flags & NDR_IN) {
26214                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26215                         NDR_PULL_ALLOC(ndr, r->in.handle);
26216                 }
26217                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26218                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26219                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26220                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26221                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26222                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26223                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26224                         return 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));
26225                 }
26226                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26227                 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));
26228                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26229                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26230                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26231                         return 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));
26232                 }
26233                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26234                 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));
26235                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
26236                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
26237                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26238                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
26239                 }
26240                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
26241                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26242                 if (r->in.buffer) {
26243                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
26244                 }
26245         }
26246         if (flags & NDR_OUT) {
26247                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26248         }
26249         return NDR_ERR_SUCCESS;
26250 }
26251
26252 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
26253 {
26254         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
26255         ndr->depth++;
26256         if (flags & NDR_SET_VALUES) {
26257                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26258         }
26259         if (flags & NDR_IN) {
26260                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
26261                 ndr->depth++;
26262                 ndr_print_ptr(ndr, "handle", r->in.handle);
26263                 ndr->depth++;
26264                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26265                 ndr->depth--;
26266                 ndr_print_string(ndr, "key_name", r->in.key_name);
26267                 ndr_print_string(ndr, "value_name", r->in.value_name);
26268                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26269                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26270                 ndr->depth++;
26271                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
26272                 ndr->depth--;
26273                 ndr_print_uint32(ndr, "offered", r->in.offered);
26274                 ndr->depth--;
26275         }
26276         if (flags & NDR_OUT) {
26277                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
26278                 ndr->depth++;
26279                 ndr_print_WERROR(ndr, "result", r->out.result);
26280                 ndr->depth--;
26281         }
26282         ndr->depth--;
26283 }
26284
26285 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
26286 {
26287         if (flags & NDR_IN) {
26288                 if (r->in.handle == NULL) {
26289                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26290                 }
26291                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26292                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26295                 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));
26296                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26298                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26299                 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));
26300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26301         }
26302         if (flags & NDR_OUT) {
26303                 if (r->out.type == NULL) {
26304                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26305                 }
26306                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26307                 if (r->out.buffer == NULL) {
26308                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26309                 }
26310                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26311                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26312                 if (r->out.needed == NULL) {
26313                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26314                 }
26315                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26316                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26317         }
26318         return NDR_ERR_SUCCESS;
26319 }
26320
26321 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26322 {
26323         TALLOC_CTX *_mem_save_handle_0;
26324         TALLOC_CTX *_mem_save_type_0;
26325         TALLOC_CTX *_mem_save_needed_0;
26326         if (flags & NDR_IN) {
26327                 ZERO_STRUCT(r->out);
26328
26329                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26330                         NDR_PULL_ALLOC(ndr, r->in.handle);
26331                 }
26332                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26333                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26334                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26335                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26336                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26337                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26338                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26339                         return 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));
26340                 }
26341                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26342                 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));
26343                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26344                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26345                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26346                         return 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));
26347                 }
26348                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26349                 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));
26350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26351                 NDR_PULL_ALLOC(ndr, r->out.type);
26352                 ZERO_STRUCTP(r->out.type);
26353                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26354                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26355                 NDR_PULL_ALLOC(ndr, r->out.needed);
26356                 ZERO_STRUCTP(r->out.needed);
26357         }
26358         if (flags & NDR_OUT) {
26359                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26360                         NDR_PULL_ALLOC(ndr, r->out.type);
26361                 }
26362                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26363                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26364                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26365                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26366                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26367                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26368                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26369                 }
26370                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26371                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26372                         NDR_PULL_ALLOC(ndr, r->out.needed);
26373                 }
26374                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26375                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26376                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26377                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26378                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26379                 if (r->out.buffer) {
26380                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26381                 }
26382         }
26383         return NDR_ERR_SUCCESS;
26384 }
26385
26386 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26387 {
26388         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26389         ndr->depth++;
26390         if (flags & NDR_SET_VALUES) {
26391                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26392         }
26393         if (flags & NDR_IN) {
26394                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26395                 ndr->depth++;
26396                 ndr_print_ptr(ndr, "handle", r->in.handle);
26397                 ndr->depth++;
26398                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26399                 ndr->depth--;
26400                 ndr_print_string(ndr, "key_name", r->in.key_name);
26401                 ndr_print_string(ndr, "value_name", r->in.value_name);
26402                 ndr_print_uint32(ndr, "offered", r->in.offered);
26403                 ndr->depth--;
26404         }
26405         if (flags & NDR_OUT) {
26406                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26407                 ndr->depth++;
26408                 ndr_print_ptr(ndr, "type", r->out.type);
26409                 ndr->depth++;
26410                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26411                 ndr->depth--;
26412                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26413                 ndr->depth++;
26414                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26415                 ndr->depth--;
26416                 ndr_print_ptr(ndr, "needed", r->out.needed);
26417                 ndr->depth++;
26418                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26419                 ndr->depth--;
26420                 ndr_print_WERROR(ndr, "result", r->out.result);
26421                 ndr->depth--;
26422         }
26423         ndr->depth--;
26424 }
26425
26426 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDataEx *r)
26427 {
26428         if (flags & NDR_IN) {
26429                 if (r->in.handle == NULL) {
26430                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26431                 }
26432                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26433                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26434                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26435                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26436                 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));
26437                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26438         }
26439         if (flags & NDR_OUT) {
26440                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
26441                 if (r->out.needed == NULL) {
26442                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26443                 }
26444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26445                 if (r->out.count == NULL) {
26446                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26447                 }
26448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26449                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26450         }
26451         return NDR_ERR_SUCCESS;
26452 }
26453
26454 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDataEx *r)
26455 {
26456         TALLOC_CTX *_mem_save_handle_0;
26457         TALLOC_CTX *_mem_save_needed_0;
26458         TALLOC_CTX *_mem_save_count_0;
26459         if (flags & NDR_IN) {
26460                 ZERO_STRUCT(r->out);
26461
26462                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26463                         NDR_PULL_ALLOC(ndr, r->in.handle);
26464                 }
26465                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26466                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26467                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26468                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26469                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26470                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26471                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26472                         return 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));
26473                 }
26474                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26475                 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));
26476                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26477                 NDR_PULL_ALLOC(ndr, r->out.needed);
26478                 ZERO_STRUCTP(r->out.needed);
26479                 NDR_PULL_ALLOC(ndr, r->out.count);
26480                 ZERO_STRUCTP(r->out.count);
26481         }
26482         if (flags & NDR_OUT) {
26483                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->out.info));
26484                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26485                         NDR_PULL_ALLOC(ndr, r->out.needed);
26486                 }
26487                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26488                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26489                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26490                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26491                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26492                         NDR_PULL_ALLOC(ndr, r->out.count);
26493                 }
26494                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26495                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26496                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26497                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26498                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26499         }
26500         return NDR_ERR_SUCCESS;
26501 }
26502
26503 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDataEx *r)
26504 {
26505         uint32_t cntr_info_0;
26506         if (flags & NDR_IN) {
26507                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
26508         }
26509         if (flags & NDR_OUT) {
26510                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26511                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26512                 }
26513                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26514                         NDR_CHECK(ndr_push_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26515                 }
26516         }
26517         return NDR_ERR_SUCCESS;
26518 }
26519
26520 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDataEx *r)
26521 {
26522         uint32_t cntr_info_0;
26523         TALLOC_CTX *_mem_save_info_0;
26524         if (flags & NDR_IN) {
26525                 ZERO_STRUCT(r->out);
26526
26527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
26528         }
26529         if (flags & NDR_OUT) {
26530                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
26531                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
26532                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
26533                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26534                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
26535                 }
26536                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
26537                         NDR_CHECK(ndr_pull_spoolss_PrinterEnumValues(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
26538                 }
26539                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
26540         }
26541         return NDR_ERR_SUCCESS;
26542 }
26543
26544 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26545 {
26546         uint32_t cntr_info_2;
26547         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26548         ndr->depth++;
26549         if (flags & NDR_SET_VALUES) {
26550                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26551         }
26552         if (flags & NDR_IN) {
26553                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26554                 ndr->depth++;
26555                 ndr_print_ptr(ndr, "handle", r->in.handle);
26556                 ndr->depth++;
26557                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26558                 ndr->depth--;
26559                 ndr_print_string(ndr, "key_name", r->in.key_name);
26560                 ndr_print_uint32(ndr, "offered", r->in.offered);
26561                 ndr->depth--;
26562         }
26563         if (flags & NDR_OUT) {
26564                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26565                 ndr->depth++;
26566                 ndr_print_ptr(ndr, "count", r->out.count);
26567                 ndr->depth++;
26568                 ndr_print_uint32(ndr, "count", *r->out.count);
26569                 ndr->depth--;
26570                 ndr_print_ptr(ndr, "info", r->out.info);
26571                 ndr->depth++;
26572                 ndr_print_ptr(ndr, "info", *r->out.info);
26573                 ndr->depth++;
26574                 if (*r->out.info) {
26575                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
26576                         ndr->depth++;
26577                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
26578                                 char *idx_2=NULL;
26579                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
26580                                         ndr_print_spoolss_PrinterEnumValues(ndr, "info", &(*r->out.info)[cntr_info_2]);
26581                                         free(idx_2);
26582                                 }
26583                         }
26584                         ndr->depth--;
26585                 }
26586                 ndr->depth--;
26587                 ndr->depth--;
26588                 ndr_print_ptr(ndr, "needed", r->out.needed);
26589                 ndr->depth++;
26590                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26591                 ndr->depth--;
26592                 ndr_print_WERROR(ndr, "result", r->out.result);
26593                 ndr->depth--;
26594         }
26595         ndr->depth--;
26596 }
26597
26598 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26599 {
26600         if (flags & NDR_IN) {
26601                 if (r->in.handle == NULL) {
26602                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26603                 }
26604                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26605                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26606                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26607                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26608                 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));
26609                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26610         }
26611         if (flags & NDR_OUT) {
26612                 {
26613                         uint32_t _flags_save_string_array = ndr->flags;
26614                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26615                         if (r->out.key_buffer == NULL) {
26616                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26617                         }
26618                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_buffer));
26619                         if (*r->out.key_buffer) {
26620                                 {
26621                                         struct ndr_push *_ndr_key_buffer;
26622                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26623                                         NDR_CHECK(ndr_push_string_array(_ndr_key_buffer, NDR_SCALARS, *r->out.key_buffer));
26624                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26625                                 }
26626                         }
26627                         ndr->flags = _flags_save_string_array;
26628                 }
26629                 if (r->out.needed == NULL) {
26630                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26631                 }
26632                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26633                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26634         }
26635         return NDR_ERR_SUCCESS;
26636 }
26637
26638 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26639 {
26640         uint32_t _ptr_key_buffer;
26641         TALLOC_CTX *_mem_save_handle_0;
26642         TALLOC_CTX *_mem_save_key_buffer_0;
26643         TALLOC_CTX *_mem_save_key_buffer_1;
26644         TALLOC_CTX *_mem_save_needed_0;
26645         if (flags & NDR_IN) {
26646                 ZERO_STRUCT(r->out);
26647
26648                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26649                         NDR_PULL_ALLOC(ndr, r->in.handle);
26650                 }
26651                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26652                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26653                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26654                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26655                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26656                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26657                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26658                         return 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));
26659                 }
26660                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26661                 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));
26662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26663                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26664                 ZERO_STRUCTP(r->out.key_buffer);
26665                 NDR_PULL_ALLOC(ndr, r->out.needed);
26666                 ZERO_STRUCTP(r->out.needed);
26667         }
26668         if (flags & NDR_OUT) {
26669                 {
26670                         uint32_t _flags_save_string_array = ndr->flags;
26671                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26672                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26673                                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26674                         }
26675                         _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26676                         NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
26677                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_buffer));
26678                         if (_ptr_key_buffer) {
26679                                 NDR_PULL_ALLOC(ndr, *r->out.key_buffer);
26680                         } else {
26681                                 *r->out.key_buffer = NULL;
26682                         }
26683                         if (*r->out.key_buffer) {
26684                                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26685                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_buffer, 0);
26686                                 {
26687                                         struct ndr_pull *_ndr_key_buffer;
26688                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26689                                         NDR_CHECK(ndr_pull_string_array(_ndr_key_buffer, NDR_SCALARS, r->out.key_buffer));
26690                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26691                                 }
26692                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26693                         }
26694                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
26695                         ndr->flags = _flags_save_string_array;
26696                 }
26697                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26698                         NDR_PULL_ALLOC(ndr, r->out.needed);
26699                 }
26700                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26701                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26702                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26703                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26704                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26705         }
26706         return NDR_ERR_SUCCESS;
26707 }
26708
26709 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26710 {
26711         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26712         ndr->depth++;
26713         if (flags & NDR_SET_VALUES) {
26714                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26715         }
26716         if (flags & NDR_IN) {
26717                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26718                 ndr->depth++;
26719                 ndr_print_ptr(ndr, "handle", r->in.handle);
26720                 ndr->depth++;
26721                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26722                 ndr->depth--;
26723                 ndr_print_string(ndr, "key_name", r->in.key_name);
26724                 ndr_print_uint32(ndr, "offered", r->in.offered);
26725                 ndr->depth--;
26726         }
26727         if (flags & NDR_OUT) {
26728                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26729                 ndr->depth++;
26730                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26731                 ndr->depth++;
26732                 ndr_print_ptr(ndr, "key_buffer", *r->out.key_buffer);
26733                 ndr->depth++;
26734                 if (*r->out.key_buffer) {
26735                         ndr_print_string_array(ndr, "key_buffer", *r->out.key_buffer);
26736                 }
26737                 ndr->depth--;
26738                 ndr->depth--;
26739                 ndr_print_ptr(ndr, "needed", r->out.needed);
26740                 ndr->depth++;
26741                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26742                 ndr->depth--;
26743                 ndr_print_WERROR(ndr, "result", r->out.result);
26744                 ndr->depth--;
26745         }
26746         ndr->depth--;
26747 }
26748
26749 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26750 {
26751         if (flags & NDR_IN) {
26752                 if (r->in.handle == NULL) {
26753                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26754                 }
26755                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26756                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26757                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26758                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26759                 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));
26760                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26761                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26762                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26763                 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));
26764         }
26765         if (flags & NDR_OUT) {
26766                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26767         }
26768         return NDR_ERR_SUCCESS;
26769 }
26770
26771 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26772 {
26773         TALLOC_CTX *_mem_save_handle_0;
26774         if (flags & NDR_IN) {
26775                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26776                         NDR_PULL_ALLOC(ndr, r->in.handle);
26777                 }
26778                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26779                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26780                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26781                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26782                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26783                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26784                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26785                         return 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));
26786                 }
26787                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26788                 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));
26789                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26790                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26791                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26792                         return 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));
26793                 }
26794                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26795                 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));
26796         }
26797         if (flags & NDR_OUT) {
26798                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26799         }
26800         return NDR_ERR_SUCCESS;
26801 }
26802
26803 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26804 {
26805         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26806         ndr->depth++;
26807         if (flags & NDR_SET_VALUES) {
26808                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26809         }
26810         if (flags & NDR_IN) {
26811                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26812                 ndr->depth++;
26813                 ndr_print_ptr(ndr, "handle", r->in.handle);
26814                 ndr->depth++;
26815                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26816                 ndr->depth--;
26817                 ndr_print_string(ndr, "key_name", r->in.key_name);
26818                 ndr_print_string(ndr, "value_name", r->in.value_name);
26819                 ndr->depth--;
26820         }
26821         if (flags & NDR_OUT) {
26822                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26823                 ndr->depth++;
26824                 ndr_print_WERROR(ndr, "result", r->out.result);
26825                 ndr->depth--;
26826         }
26827         ndr->depth--;
26828 }
26829
26830 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26831 {
26832         if (flags & NDR_IN) {
26833                 if (r->in.handle == NULL) {
26834                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26835                 }
26836                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26837                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26838                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26839                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26840                 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));
26841         }
26842         if (flags & NDR_OUT) {
26843                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26844         }
26845         return NDR_ERR_SUCCESS;
26846 }
26847
26848 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26849 {
26850         TALLOC_CTX *_mem_save_handle_0;
26851         if (flags & NDR_IN) {
26852                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26853                         NDR_PULL_ALLOC(ndr, r->in.handle);
26854                 }
26855                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26856                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26857                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26858                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26859                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26860                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26861                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26862                         return 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));
26863                 }
26864                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26865                 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));
26866         }
26867         if (flags & NDR_OUT) {
26868                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26869         }
26870         return NDR_ERR_SUCCESS;
26871 }
26872
26873 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26874 {
26875         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26876         ndr->depth++;
26877         if (flags & NDR_SET_VALUES) {
26878                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26879         }
26880         if (flags & NDR_IN) {
26881                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26882                 ndr->depth++;
26883                 ndr_print_ptr(ndr, "handle", r->in.handle);
26884                 ndr->depth++;
26885                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26886                 ndr->depth--;
26887                 ndr_print_string(ndr, "key_name", r->in.key_name);
26888                 ndr->depth--;
26889         }
26890         if (flags & NDR_OUT) {
26891                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26892                 ndr->depth++;
26893                 ndr_print_WERROR(ndr, "result", r->out.result);
26894                 ndr->depth--;
26895         }
26896         ndr->depth--;
26897 }
26898
26899 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26900 {
26901         if (flags & NDR_IN) {
26902         }
26903         if (flags & NDR_OUT) {
26904                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26905         }
26906         return NDR_ERR_SUCCESS;
26907 }
26908
26909 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26910 {
26911         if (flags & NDR_IN) {
26912         }
26913         if (flags & NDR_OUT) {
26914                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26915         }
26916         return NDR_ERR_SUCCESS;
26917 }
26918
26919 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26920 {
26921         ndr_print_struct(ndr, name, "spoolss_53");
26922         ndr->depth++;
26923         if (flags & NDR_SET_VALUES) {
26924                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26925         }
26926         if (flags & NDR_IN) {
26927                 ndr_print_struct(ndr, "in", "spoolss_53");
26928                 ndr->depth++;
26929                 ndr->depth--;
26930         }
26931         if (flags & NDR_OUT) {
26932                 ndr_print_struct(ndr, "out", "spoolss_53");
26933                 ndr->depth++;
26934                 ndr_print_WERROR(ndr, "result", r->out.result);
26935                 ndr->depth--;
26936         }
26937         ndr->depth--;
26938 }
26939
26940 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26941 {
26942         if (flags & NDR_IN) {
26943                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26944                 if (r->in.server) {
26945                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26946                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26947                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26948                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26949                 }
26950                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26951                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26952                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26953                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26955                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26956                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26957                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26958                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26959                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26960         }
26961         if (flags & NDR_OUT) {
26962                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26963         }
26964         return NDR_ERR_SUCCESS;
26965 }
26966
26967 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26968 {
26969         uint32_t _ptr_server;
26970         TALLOC_CTX *_mem_save_server_0;
26971         if (flags & NDR_IN) {
26972                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26973                 if (_ptr_server) {
26974                         NDR_PULL_ALLOC(ndr, r->in.server);
26975                 } else {
26976                         r->in.server = NULL;
26977                 }
26978                 if (r->in.server) {
26979                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26980                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26981                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26982                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26983                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26984                                 return 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));
26985                         }
26986                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26987                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26988                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26989                 }
26990                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26991                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26992                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26993                         return 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));
26994                 }
26995                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26996                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26997                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26998                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26999                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
27000                         return 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));
27001                 }
27002                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
27003                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
27004                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
27005                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
27006         }
27007         if (flags & NDR_OUT) {
27008                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27009         }
27010         return NDR_ERR_SUCCESS;
27011 }
27012
27013 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
27014 {
27015         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
27016         ndr->depth++;
27017         if (flags & NDR_SET_VALUES) {
27018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27019         }
27020         if (flags & NDR_IN) {
27021                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
27022                 ndr->depth++;
27023                 ndr_print_ptr(ndr, "server", r->in.server);
27024                 ndr->depth++;
27025                 if (r->in.server) {
27026                         ndr_print_string(ndr, "server", r->in.server);
27027                 }
27028                 ndr->depth--;
27029                 ndr_print_string(ndr, "architecture", r->in.architecture);
27030                 ndr_print_string(ndr, "driver", r->in.driver);
27031                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
27032                 ndr_print_uint32(ndr, "version", r->in.version);
27033                 ndr->depth--;
27034         }
27035         if (flags & NDR_OUT) {
27036                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
27037                 ndr->depth++;
27038                 ndr_print_WERROR(ndr, "result", r->out.result);
27039                 ndr->depth--;
27040         }
27041         ndr->depth--;
27042 }
27043
27044 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
27045 {
27046         if (flags & NDR_IN) {
27047         }
27048         if (flags & NDR_OUT) {
27049                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27050         }
27051         return NDR_ERR_SUCCESS;
27052 }
27053
27054 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
27055 {
27056         if (flags & NDR_IN) {
27057         }
27058         if (flags & NDR_OUT) {
27059                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27060         }
27061         return NDR_ERR_SUCCESS;
27062 }
27063
27064 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
27065 {
27066         ndr_print_struct(ndr, name, "spoolss_55");
27067         ndr->depth++;
27068         if (flags & NDR_SET_VALUES) {
27069                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27070         }
27071         if (flags & NDR_IN) {
27072                 ndr_print_struct(ndr, "in", "spoolss_55");
27073                 ndr->depth++;
27074                 ndr->depth--;
27075         }
27076         if (flags & NDR_OUT) {
27077                 ndr_print_struct(ndr, "out", "spoolss_55");
27078                 ndr->depth++;
27079                 ndr_print_WERROR(ndr, "result", r->out.result);
27080                 ndr->depth--;
27081         }
27082         ndr->depth--;
27083 }
27084
27085 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
27086 {
27087         if (flags & NDR_IN) {
27088         }
27089         if (flags & NDR_OUT) {
27090                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27091         }
27092         return NDR_ERR_SUCCESS;
27093 }
27094
27095 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
27096 {
27097         if (flags & NDR_IN) {
27098         }
27099         if (flags & NDR_OUT) {
27100                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27101         }
27102         return NDR_ERR_SUCCESS;
27103 }
27104
27105 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
27106 {
27107         ndr_print_struct(ndr, name, "spoolss_56");
27108         ndr->depth++;
27109         if (flags & NDR_SET_VALUES) {
27110                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27111         }
27112         if (flags & NDR_IN) {
27113                 ndr_print_struct(ndr, "in", "spoolss_56");
27114                 ndr->depth++;
27115                 ndr->depth--;
27116         }
27117         if (flags & NDR_OUT) {
27118                 ndr_print_struct(ndr, "out", "spoolss_56");
27119                 ndr->depth++;
27120                 ndr_print_WERROR(ndr, "result", r->out.result);
27121                 ndr->depth--;
27122         }
27123         ndr->depth--;
27124 }
27125
27126 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
27127 {
27128         if (flags & NDR_IN) {
27129         }
27130         if (flags & NDR_OUT) {
27131                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27132         }
27133         return NDR_ERR_SUCCESS;
27134 }
27135
27136 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
27137 {
27138         if (flags & NDR_IN) {
27139         }
27140         if (flags & NDR_OUT) {
27141                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27142         }
27143         return NDR_ERR_SUCCESS;
27144 }
27145
27146 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
27147 {
27148         ndr_print_struct(ndr, name, "spoolss_57");
27149         ndr->depth++;
27150         if (flags & NDR_SET_VALUES) {
27151                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27152         }
27153         if (flags & NDR_IN) {
27154                 ndr_print_struct(ndr, "in", "spoolss_57");
27155                 ndr->depth++;
27156                 ndr->depth--;
27157         }
27158         if (flags & NDR_OUT) {
27159                 ndr_print_struct(ndr, "out", "spoolss_57");
27160                 ndr->depth++;
27161                 ndr_print_WERROR(ndr, "result", r->out.result);
27162                 ndr->depth--;
27163         }
27164         ndr->depth--;
27165 }
27166
27167 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
27168 {
27169         if (flags & NDR_IN) {
27170                 if (r->in.handle == NULL) {
27171                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27172                 }
27173                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27175                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27176                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
27177                 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));
27178                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
27179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
27180                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27181                 if (r->in.status_code == NULL) {
27182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27183                 }
27184                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
27185         }
27186         if (flags & NDR_OUT) {
27187                 if (r->out.out_data == NULL) {
27188                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27189                 }
27190                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
27191                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
27192                 if (r->out.needed == NULL) {
27193                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27194                 }
27195                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
27196                 if (r->out.status_code == NULL) {
27197                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27198                 }
27199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
27200                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27201         }
27202         return NDR_ERR_SUCCESS;
27203 }
27204
27205 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
27206 {
27207         TALLOC_CTX *_mem_save_handle_0;
27208         TALLOC_CTX *_mem_save_needed_0;
27209         TALLOC_CTX *_mem_save_status_code_0;
27210         if (flags & NDR_IN) {
27211                 ZERO_STRUCT(r->out);
27212
27213                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27214                         NDR_PULL_ALLOC(ndr, r->in.handle);
27215                 }
27216                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
27217                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
27218                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
27219                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
27220                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
27221                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
27222                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
27223                         return 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));
27224                 }
27225                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
27226                 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));
27227                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
27228                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
27229                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
27230                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27231                         NDR_PULL_ALLOC(ndr, r->in.status_code);
27232                 }
27233                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27234                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
27235                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
27236                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27237                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
27238                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
27239                 NDR_PULL_ALLOC(ndr, r->out.needed);
27240                 ZERO_STRUCTP(r->out.needed);
27241                 NDR_PULL_ALLOC(ndr, r->out.status_code);
27242                 *r->out.status_code = *r->in.status_code;
27243         }
27244         if (flags & NDR_OUT) {
27245                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
27246                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27247                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
27248                 }
27249                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
27250                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27251                         NDR_PULL_ALLOC(ndr, r->out.needed);
27252                 }
27253                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
27254                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
27255                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
27256                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
27257                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27258                         NDR_PULL_ALLOC(ndr, r->out.status_code);
27259                 }
27260                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
27261                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
27262                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
27263                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
27264                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27265                 if (r->out.out_data) {
27266                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
27267                 }
27268         }
27269         return NDR_ERR_SUCCESS;
27270 }
27271
27272 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
27273 {
27274         ndr_print_struct(ndr, name, "spoolss_XcvData");
27275         ndr->depth++;
27276         if (flags & NDR_SET_VALUES) {
27277                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27278         }
27279         if (flags & NDR_IN) {
27280                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
27281                 ndr->depth++;
27282                 ndr_print_ptr(ndr, "handle", r->in.handle);
27283                 ndr->depth++;
27284                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
27285                 ndr->depth--;
27286                 ndr_print_string(ndr, "function_name", r->in.function_name);
27287                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
27288                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
27289                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
27290                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
27291                 ndr->depth++;
27292                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
27293                 ndr->depth--;
27294                 ndr->depth--;
27295         }
27296         if (flags & NDR_OUT) {
27297                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
27298                 ndr->depth++;
27299                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
27300                 ndr->depth++;
27301                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
27302                 ndr->depth--;
27303                 ndr_print_ptr(ndr, "needed", r->out.needed);
27304                 ndr->depth++;
27305                 ndr_print_uint32(ndr, "needed", *r->out.needed);
27306                 ndr->depth--;
27307                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
27308                 ndr->depth++;
27309                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
27310                 ndr->depth--;
27311                 ndr_print_WERROR(ndr, "result", r->out.result);
27312                 ndr->depth--;
27313         }
27314         ndr->depth--;
27315 }
27316
27317 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
27318 {
27319         if (flags & NDR_IN) {
27320                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
27321                 if (r->in.servername) {
27322                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27323                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27324                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27325                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27326                 }
27327                 if (r->in.info_ctr == NULL) {
27328                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27329                 }
27330                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27331                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
27332         }
27333         if (flags & NDR_OUT) {
27334                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27335         }
27336         return NDR_ERR_SUCCESS;
27337 }
27338
27339 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
27340 {
27341         uint32_t _ptr_servername;
27342         TALLOC_CTX *_mem_save_servername_0;
27343         TALLOC_CTX *_mem_save_info_ctr_0;
27344         if (flags & NDR_IN) {
27345                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
27346                 if (_ptr_servername) {
27347                         NDR_PULL_ALLOC(ndr, r->in.servername);
27348                 } else {
27349                         r->in.servername = NULL;
27350                 }
27351                 if (r->in.servername) {
27352                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27353                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
27354                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
27355                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
27356                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
27357                                 return 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));
27358                         }
27359                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
27360                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
27361                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
27362                 }
27363                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27364                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27365                 }
27366                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27367                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27368                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27369                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27370                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27371         }
27372         if (flags & NDR_OUT) {
27373                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27374         }
27375         return NDR_ERR_SUCCESS;
27376 }
27377
27378 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27379 {
27380         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27381         ndr->depth++;
27382         if (flags & NDR_SET_VALUES) {
27383                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27384         }
27385         if (flags & NDR_IN) {
27386                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27387                 ndr->depth++;
27388                 ndr_print_ptr(ndr, "servername", r->in.servername);
27389                 ndr->depth++;
27390                 if (r->in.servername) {
27391                         ndr_print_string(ndr, "servername", r->in.servername);
27392                 }
27393                 ndr->depth--;
27394                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27395                 ndr->depth++;
27396                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27397                 ndr->depth--;
27398                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
27399                 ndr->depth--;
27400         }
27401         if (flags & NDR_OUT) {
27402                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
27403                 ndr->depth++;
27404                 ndr_print_WERROR(ndr, "result", r->out.result);
27405                 ndr->depth--;
27406         }
27407         ndr->depth--;
27408 }
27409
27410 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
27411 {
27412         if (flags & NDR_IN) {
27413         }
27414         if (flags & NDR_OUT) {
27415                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27416         }
27417         return NDR_ERR_SUCCESS;
27418 }
27419
27420 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27421 {
27422         if (flags & NDR_IN) {
27423         }
27424         if (flags & NDR_OUT) {
27425                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27426         }
27427         return NDR_ERR_SUCCESS;
27428 }
27429
27430 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27431 {
27432         ndr_print_struct(ndr, name, "spoolss_5a");
27433         ndr->depth++;
27434         if (flags & NDR_SET_VALUES) {
27435                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27436         }
27437         if (flags & NDR_IN) {
27438                 ndr_print_struct(ndr, "in", "spoolss_5a");
27439                 ndr->depth++;
27440                 ndr->depth--;
27441         }
27442         if (flags & NDR_OUT) {
27443                 ndr_print_struct(ndr, "out", "spoolss_5a");
27444                 ndr->depth++;
27445                 ndr_print_WERROR(ndr, "result", r->out.result);
27446                 ndr->depth--;
27447         }
27448         ndr->depth--;
27449 }
27450
27451 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27452 {
27453         if (flags & NDR_IN) {
27454         }
27455         if (flags & NDR_OUT) {
27456                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27457         }
27458         return NDR_ERR_SUCCESS;
27459 }
27460
27461 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27462 {
27463         if (flags & NDR_IN) {
27464         }
27465         if (flags & NDR_OUT) {
27466                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27467         }
27468         return NDR_ERR_SUCCESS;
27469 }
27470
27471 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27472 {
27473         ndr_print_struct(ndr, name, "spoolss_5b");
27474         ndr->depth++;
27475         if (flags & NDR_SET_VALUES) {
27476                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27477         }
27478         if (flags & NDR_IN) {
27479                 ndr_print_struct(ndr, "in", "spoolss_5b");
27480                 ndr->depth++;
27481                 ndr->depth--;
27482         }
27483         if (flags & NDR_OUT) {
27484                 ndr_print_struct(ndr, "out", "spoolss_5b");
27485                 ndr->depth++;
27486                 ndr_print_WERROR(ndr, "result", r->out.result);
27487                 ndr->depth--;
27488         }
27489         ndr->depth--;
27490 }
27491
27492 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27493 {
27494         if (flags & NDR_IN) {
27495         }
27496         if (flags & NDR_OUT) {
27497                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27498         }
27499         return NDR_ERR_SUCCESS;
27500 }
27501
27502 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27503 {
27504         if (flags & NDR_IN) {
27505         }
27506         if (flags & NDR_OUT) {
27507                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27508         }
27509         return NDR_ERR_SUCCESS;
27510 }
27511
27512 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27513 {
27514         ndr_print_struct(ndr, name, "spoolss_5c");
27515         ndr->depth++;
27516         if (flags & NDR_SET_VALUES) {
27517                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27518         }
27519         if (flags & NDR_IN) {
27520                 ndr_print_struct(ndr, "in", "spoolss_5c");
27521                 ndr->depth++;
27522                 ndr->depth--;
27523         }
27524         if (flags & NDR_OUT) {
27525                 ndr_print_struct(ndr, "out", "spoolss_5c");
27526                 ndr->depth++;
27527                 ndr_print_WERROR(ndr, "result", r->out.result);
27528                 ndr->depth--;
27529         }
27530         ndr->depth--;
27531 }
27532
27533 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27534 {
27535         if (flags & NDR_IN) {
27536         }
27537         if (flags & NDR_OUT) {
27538                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27539         }
27540         return NDR_ERR_SUCCESS;
27541 }
27542
27543 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27544 {
27545         if (flags & NDR_IN) {
27546         }
27547         if (flags & NDR_OUT) {
27548                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27549         }
27550         return NDR_ERR_SUCCESS;
27551 }
27552
27553 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27554 {
27555         ndr_print_struct(ndr, name, "spoolss_5d");
27556         ndr->depth++;
27557         if (flags & NDR_SET_VALUES) {
27558                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27559         }
27560         if (flags & NDR_IN) {
27561                 ndr_print_struct(ndr, "in", "spoolss_5d");
27562                 ndr->depth++;
27563                 ndr->depth--;
27564         }
27565         if (flags & NDR_OUT) {
27566                 ndr_print_struct(ndr, "out", "spoolss_5d");
27567                 ndr->depth++;
27568                 ndr_print_WERROR(ndr, "result", r->out.result);
27569                 ndr->depth--;
27570         }
27571         ndr->depth--;
27572 }
27573
27574 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27575 {
27576         if (flags & NDR_IN) {
27577         }
27578         if (flags & NDR_OUT) {
27579                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27580         }
27581         return NDR_ERR_SUCCESS;
27582 }
27583
27584 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27585 {
27586         if (flags & NDR_IN) {
27587         }
27588         if (flags & NDR_OUT) {
27589                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27590         }
27591         return NDR_ERR_SUCCESS;
27592 }
27593
27594 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27595 {
27596         ndr_print_struct(ndr, name, "spoolss_5e");
27597         ndr->depth++;
27598         if (flags & NDR_SET_VALUES) {
27599                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27600         }
27601         if (flags & NDR_IN) {
27602                 ndr_print_struct(ndr, "in", "spoolss_5e");
27603                 ndr->depth++;
27604                 ndr->depth--;
27605         }
27606         if (flags & NDR_OUT) {
27607                 ndr_print_struct(ndr, "out", "spoolss_5e");
27608                 ndr->depth++;
27609                 ndr_print_WERROR(ndr, "result", r->out.result);
27610                 ndr->depth--;
27611         }
27612         ndr->depth--;
27613 }
27614
27615 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27616 {
27617         if (flags & NDR_IN) {
27618         }
27619         if (flags & NDR_OUT) {
27620                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27621         }
27622         return NDR_ERR_SUCCESS;
27623 }
27624
27625 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27626 {
27627         if (flags & NDR_IN) {
27628         }
27629         if (flags & NDR_OUT) {
27630                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27631         }
27632         return NDR_ERR_SUCCESS;
27633 }
27634
27635 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27636 {
27637         ndr_print_struct(ndr, name, "spoolss_5f");
27638         ndr->depth++;
27639         if (flags & NDR_SET_VALUES) {
27640                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27641         }
27642         if (flags & NDR_IN) {
27643                 ndr_print_struct(ndr, "in", "spoolss_5f");
27644                 ndr->depth++;
27645                 ndr->depth--;
27646         }
27647         if (flags & NDR_OUT) {
27648                 ndr_print_struct(ndr, "out", "spoolss_5f");
27649                 ndr->depth++;
27650                 ndr_print_WERROR(ndr, "result", r->out.result);
27651                 ndr->depth--;
27652         }
27653         ndr->depth--;
27654 }
27655
27656 static const struct ndr_interface_call spoolss_calls[] = {
27657         {
27658                 "spoolss_EnumPrinters",
27659                 sizeof(struct spoolss_EnumPrinters),
27660                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27662                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27663                 false,
27664         },
27665         {
27666                 "spoolss_OpenPrinter",
27667                 sizeof(struct spoolss_OpenPrinter),
27668                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27670                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27671                 false,
27672         },
27673         {
27674                 "spoolss_SetJob",
27675                 sizeof(struct spoolss_SetJob),
27676                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27678                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27679                 false,
27680         },
27681         {
27682                 "spoolss_GetJob",
27683                 sizeof(struct spoolss_GetJob),
27684                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27686                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27687                 false,
27688         },
27689         {
27690                 "spoolss_EnumJobs",
27691                 sizeof(struct spoolss_EnumJobs),
27692                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27694                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27695                 false,
27696         },
27697         {
27698                 "spoolss_AddPrinter",
27699                 sizeof(struct spoolss_AddPrinter),
27700                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27702                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27703                 false,
27704         },
27705         {
27706                 "spoolss_DeletePrinter",
27707                 sizeof(struct spoolss_DeletePrinter),
27708                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27710                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27711                 false,
27712         },
27713         {
27714                 "spoolss_SetPrinter",
27715                 sizeof(struct spoolss_SetPrinter),
27716                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27718                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27719                 false,
27720         },
27721         {
27722                 "spoolss_GetPrinter",
27723                 sizeof(struct spoolss_GetPrinter),
27724                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27726                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27727                 false,
27728         },
27729         {
27730                 "spoolss_AddPrinterDriver",
27731                 sizeof(struct spoolss_AddPrinterDriver),
27732                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27734                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27735                 false,
27736         },
27737         {
27738                 "spoolss_EnumPrinterDrivers",
27739                 sizeof(struct spoolss_EnumPrinterDrivers),
27740                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27742                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27743                 false,
27744         },
27745         {
27746                 "spoolss_GetPrinterDriver",
27747                 sizeof(struct spoolss_GetPrinterDriver),
27748                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27750                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27751                 false,
27752         },
27753         {
27754                 "spoolss_GetPrinterDriverDirectory",
27755                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27756                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27758                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27759                 false,
27760         },
27761         {
27762                 "spoolss_DeletePrinterDriver",
27763                 sizeof(struct spoolss_DeletePrinterDriver),
27764                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27766                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27767                 false,
27768         },
27769         {
27770                 "spoolss_AddPrintProcessor",
27771                 sizeof(struct spoolss_AddPrintProcessor),
27772                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27774                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27775                 false,
27776         },
27777         {
27778                 "spoolss_EnumPrintProcessors",
27779                 sizeof(struct spoolss_EnumPrintProcessors),
27780                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27782                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27783                 false,
27784         },
27785         {
27786                 "spoolss_GetPrintProcessorDirectory",
27787                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27788                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27790                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27791                 false,
27792         },
27793         {
27794                 "spoolss_StartDocPrinter",
27795                 sizeof(struct spoolss_StartDocPrinter),
27796                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27798                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27799                 false,
27800         },
27801         {
27802                 "spoolss_StartPagePrinter",
27803                 sizeof(struct spoolss_StartPagePrinter),
27804                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27806                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27807                 false,
27808         },
27809         {
27810                 "spoolss_WritePrinter",
27811                 sizeof(struct spoolss_WritePrinter),
27812                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27814                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27815                 false,
27816         },
27817         {
27818                 "spoolss_EndPagePrinter",
27819                 sizeof(struct spoolss_EndPagePrinter),
27820                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27822                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27823                 false,
27824         },
27825         {
27826                 "spoolss_AbortPrinter",
27827                 sizeof(struct spoolss_AbortPrinter),
27828                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27830                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27831                 false,
27832         },
27833         {
27834                 "spoolss_ReadPrinter",
27835                 sizeof(struct spoolss_ReadPrinter),
27836                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27838                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27839                 false,
27840         },
27841         {
27842                 "spoolss_EndDocPrinter",
27843                 sizeof(struct spoolss_EndDocPrinter),
27844                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27846                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27847                 false,
27848         },
27849         {
27850                 "spoolss_AddJob",
27851                 sizeof(struct spoolss_AddJob),
27852                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27854                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27855                 false,
27856         },
27857         {
27858                 "spoolss_ScheduleJob",
27859                 sizeof(struct spoolss_ScheduleJob),
27860                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27862                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27863                 false,
27864         },
27865         {
27866                 "spoolss_GetPrinterData",
27867                 sizeof(struct spoolss_GetPrinterData),
27868                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27870                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27871                 false,
27872         },
27873         {
27874                 "spoolss_SetPrinterData",
27875                 sizeof(struct spoolss_SetPrinterData),
27876                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27878                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27879                 false,
27880         },
27881         {
27882                 "spoolss_WaitForPrinterChange",
27883                 sizeof(struct spoolss_WaitForPrinterChange),
27884                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27886                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27887                 false,
27888         },
27889         {
27890                 "spoolss_ClosePrinter",
27891                 sizeof(struct spoolss_ClosePrinter),
27892                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27894                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27895                 false,
27896         },
27897         {
27898                 "spoolss_AddForm",
27899                 sizeof(struct spoolss_AddForm),
27900                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27902                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27903                 false,
27904         },
27905         {
27906                 "spoolss_DeleteForm",
27907                 sizeof(struct spoolss_DeleteForm),
27908                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27910                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27911                 false,
27912         },
27913         {
27914                 "spoolss_GetForm",
27915                 sizeof(struct spoolss_GetForm),
27916                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27918                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27919                 false,
27920         },
27921         {
27922                 "spoolss_SetForm",
27923                 sizeof(struct spoolss_SetForm),
27924                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27926                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27927                 false,
27928         },
27929         {
27930                 "spoolss_EnumForms",
27931                 sizeof(struct spoolss_EnumForms),
27932                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27934                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27935                 false,
27936         },
27937         {
27938                 "spoolss_EnumPorts",
27939                 sizeof(struct spoolss_EnumPorts),
27940                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27942                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27943                 false,
27944         },
27945         {
27946                 "spoolss_EnumMonitors",
27947                 sizeof(struct spoolss_EnumMonitors),
27948                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27950                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27951                 false,
27952         },
27953         {
27954                 "spoolss_AddPort",
27955                 sizeof(struct spoolss_AddPort),
27956                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27958                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27959                 false,
27960         },
27961         {
27962                 "spoolss_ConfigurePort",
27963                 sizeof(struct spoolss_ConfigurePort),
27964                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27966                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27967                 false,
27968         },
27969         {
27970                 "spoolss_DeletePort",
27971                 sizeof(struct spoolss_DeletePort),
27972                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27974                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27975                 false,
27976         },
27977         {
27978                 "spoolss_CreatePrinterIC",
27979                 sizeof(struct spoolss_CreatePrinterIC),
27980                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27982                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27983                 false,
27984         },
27985         {
27986                 "spoolss_PlayGDIScriptOnPrinterIC",
27987                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27988                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27990                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27991                 false,
27992         },
27993         {
27994                 "spoolss_DeletePrinterIC",
27995                 sizeof(struct spoolss_DeletePrinterIC),
27996                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27998                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27999                 false,
28000         },
28001         {
28002                 "spoolss_AddPrinterConnection",
28003                 sizeof(struct spoolss_AddPrinterConnection),
28004                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
28005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
28006                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
28007                 false,
28008         },
28009         {
28010                 "spoolss_DeletePrinterConnection",
28011                 sizeof(struct spoolss_DeletePrinterConnection),
28012                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
28013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
28014                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
28015                 false,
28016         },
28017         {
28018                 "spoolss_PrinterMessageBox",
28019                 sizeof(struct spoolss_PrinterMessageBox),
28020                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
28021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
28022                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
28023                 false,
28024         },
28025         {
28026                 "spoolss_AddMonitor",
28027                 sizeof(struct spoolss_AddMonitor),
28028                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
28029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
28030                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
28031                 false,
28032         },
28033         {
28034                 "spoolss_DeleteMonitor",
28035                 sizeof(struct spoolss_DeleteMonitor),
28036                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
28037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
28038                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
28039                 false,
28040         },
28041         {
28042                 "spoolss_DeletePrintProcessor",
28043                 sizeof(struct spoolss_DeletePrintProcessor),
28044                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
28045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
28046                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
28047                 false,
28048         },
28049         {
28050                 "spoolss_AddPrintProvidor",
28051                 sizeof(struct spoolss_AddPrintProvidor),
28052                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
28053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
28054                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
28055                 false,
28056         },
28057         {
28058                 "spoolss_DeletePrintProvidor",
28059                 sizeof(struct spoolss_DeletePrintProvidor),
28060                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
28061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
28062                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
28063                 false,
28064         },
28065         {
28066                 "spoolss_EnumPrintProcDataTypes",
28067                 sizeof(struct spoolss_EnumPrintProcDataTypes),
28068                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
28069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
28070                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
28071                 false,
28072         },
28073         {
28074                 "spoolss_ResetPrinter",
28075                 sizeof(struct spoolss_ResetPrinter),
28076                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
28077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
28078                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
28079                 false,
28080         },
28081         {
28082                 "spoolss_GetPrinterDriver2",
28083                 sizeof(struct spoolss_GetPrinterDriver2),
28084                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
28085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
28086                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
28087                 false,
28088         },
28089         {
28090                 "spoolss_FindFirstPrinterChangeNotification",
28091                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
28092                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
28093                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
28094                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
28095                 false,
28096         },
28097         {
28098                 "spoolss_FindNextPrinterChangeNotification",
28099                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
28100                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
28101                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
28102                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
28103                 false,
28104         },
28105         {
28106                 "spoolss_FindClosePrinterNotify",
28107                 sizeof(struct spoolss_FindClosePrinterNotify),
28108                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
28109                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
28110                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
28111                 false,
28112         },
28113         {
28114                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
28115                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
28116                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28117                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28118                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
28119                 false,
28120         },
28121         {
28122                 "spoolss_ReplyOpenPrinter",
28123                 sizeof(struct spoolss_ReplyOpenPrinter),
28124                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
28125                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
28126                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
28127                 false,
28128         },
28129         {
28130                 "spoolss_RouterReplyPrinter",
28131                 sizeof(struct spoolss_RouterReplyPrinter),
28132                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
28133                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
28134                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
28135                 false,
28136         },
28137         {
28138                 "spoolss_ReplyClosePrinter",
28139                 sizeof(struct spoolss_ReplyClosePrinter),
28140                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
28141                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
28142                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
28143                 false,
28144         },
28145         {
28146                 "spoolss_AddPortEx",
28147                 sizeof(struct spoolss_AddPortEx),
28148                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
28149                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
28150                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
28151                 false,
28152         },
28153         {
28154                 "spoolss_RouterFindFirstPrinterChangeNotification",
28155                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
28156                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
28157                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
28158                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
28159                 false,
28160         },
28161         {
28162                 "spoolss_SpoolerInit",
28163                 sizeof(struct spoolss_SpoolerInit),
28164                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
28165                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
28166                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
28167                 false,
28168         },
28169         {
28170                 "spoolss_ResetPrinterEx",
28171                 sizeof(struct spoolss_ResetPrinterEx),
28172                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
28173                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
28174                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
28175                 false,
28176         },
28177         {
28178                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
28179                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
28180                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28181                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28182                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
28183                 false,
28184         },
28185         {
28186                 "spoolss_RouterReplyPrinterEx",
28187                 sizeof(struct spoolss_RouterReplyPrinterEx),
28188                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
28189                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
28190                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
28191                 false,
28192         },
28193         {
28194                 "spoolss_RouterRefreshPrinterChangeNotify",
28195                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
28196                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
28197                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
28198                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
28199                 false,
28200         },
28201         {
28202                 "spoolss_44",
28203                 sizeof(struct spoolss_44),
28204                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
28205                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
28206                 (ndr_print_function_t) ndr_print_spoolss_44,
28207                 false,
28208         },
28209         {
28210                 "spoolss_OpenPrinterEx",
28211                 sizeof(struct spoolss_OpenPrinterEx),
28212                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
28213                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
28214                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
28215                 false,
28216         },
28217         {
28218                 "spoolss_AddPrinterEx",
28219                 sizeof(struct spoolss_AddPrinterEx),
28220                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
28221                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
28222                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
28223                 false,
28224         },
28225         {
28226                 "spoolss_47",
28227                 sizeof(struct spoolss_47),
28228                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
28229                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
28230                 (ndr_print_function_t) ndr_print_spoolss_47,
28231                 false,
28232         },
28233         {
28234                 "spoolss_EnumPrinterData",
28235                 sizeof(struct spoolss_EnumPrinterData),
28236                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
28237                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
28238                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
28239                 false,
28240         },
28241         {
28242                 "spoolss_DeletePrinterData",
28243                 sizeof(struct spoolss_DeletePrinterData),
28244                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
28245                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
28246                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
28247                 false,
28248         },
28249         {
28250                 "spoolss_4a",
28251                 sizeof(struct spoolss_4a),
28252                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
28253                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
28254                 (ndr_print_function_t) ndr_print_spoolss_4a,
28255                 false,
28256         },
28257         {
28258                 "spoolss_4b",
28259                 sizeof(struct spoolss_4b),
28260                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
28261                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
28262                 (ndr_print_function_t) ndr_print_spoolss_4b,
28263                 false,
28264         },
28265         {
28266                 "spoolss_4c",
28267                 sizeof(struct spoolss_4c),
28268                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
28269                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
28270                 (ndr_print_function_t) ndr_print_spoolss_4c,
28271                 false,
28272         },
28273         {
28274                 "spoolss_SetPrinterDataEx",
28275                 sizeof(struct spoolss_SetPrinterDataEx),
28276                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
28277                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
28278                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
28279                 false,
28280         },
28281         {
28282                 "spoolss_GetPrinterDataEx",
28283                 sizeof(struct spoolss_GetPrinterDataEx),
28284                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
28285                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
28286                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
28287                 false,
28288         },
28289         {
28290                 "spoolss_EnumPrinterDataEx",
28291                 sizeof(struct spoolss_EnumPrinterDataEx),
28292                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
28293                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
28294                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
28295                 false,
28296         },
28297         {
28298                 "spoolss_EnumPrinterKey",
28299                 sizeof(struct spoolss_EnumPrinterKey),
28300                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
28301                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
28302                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
28303                 false,
28304         },
28305         {
28306                 "spoolss_DeletePrinterDataEx",
28307                 sizeof(struct spoolss_DeletePrinterDataEx),
28308                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
28309                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
28310                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
28311                 false,
28312         },
28313         {
28314                 "spoolss_DeletePrinterKey",
28315                 sizeof(struct spoolss_DeletePrinterKey),
28316                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
28317                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
28318                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
28319                 false,
28320         },
28321         {
28322                 "spoolss_53",
28323                 sizeof(struct spoolss_53),
28324                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
28325                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
28326                 (ndr_print_function_t) ndr_print_spoolss_53,
28327                 false,
28328         },
28329         {
28330                 "spoolss_DeletePrinterDriverEx",
28331                 sizeof(struct spoolss_DeletePrinterDriverEx),
28332                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
28333                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
28334                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
28335                 false,
28336         },
28337         {
28338                 "spoolss_55",
28339                 sizeof(struct spoolss_55),
28340                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
28341                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
28342                 (ndr_print_function_t) ndr_print_spoolss_55,
28343                 false,
28344         },
28345         {
28346                 "spoolss_56",
28347                 sizeof(struct spoolss_56),
28348                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
28349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
28350                 (ndr_print_function_t) ndr_print_spoolss_56,
28351                 false,
28352         },
28353         {
28354                 "spoolss_57",
28355                 sizeof(struct spoolss_57),
28356                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
28357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
28358                 (ndr_print_function_t) ndr_print_spoolss_57,
28359                 false,
28360         },
28361         {
28362                 "spoolss_XcvData",
28363                 sizeof(struct spoolss_XcvData),
28364                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
28365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
28366                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
28367                 false,
28368         },
28369         {
28370                 "spoolss_AddPrinterDriverEx",
28371                 sizeof(struct spoolss_AddPrinterDriverEx),
28372                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28374                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28375                 false,
28376         },
28377         {
28378                 "spoolss_5a",
28379                 sizeof(struct spoolss_5a),
28380                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28382                 (ndr_print_function_t) ndr_print_spoolss_5a,
28383                 false,
28384         },
28385         {
28386                 "spoolss_5b",
28387                 sizeof(struct spoolss_5b),
28388                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28390                 (ndr_print_function_t) ndr_print_spoolss_5b,
28391                 false,
28392         },
28393         {
28394                 "spoolss_5c",
28395                 sizeof(struct spoolss_5c),
28396                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
28397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
28398                 (ndr_print_function_t) ndr_print_spoolss_5c,
28399                 false,
28400         },
28401         {
28402                 "spoolss_5d",
28403                 sizeof(struct spoolss_5d),
28404                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
28405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
28406                 (ndr_print_function_t) ndr_print_spoolss_5d,
28407                 false,
28408         },
28409         {
28410                 "spoolss_5e",
28411                 sizeof(struct spoolss_5e),
28412                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
28413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28414                 (ndr_print_function_t) ndr_print_spoolss_5e,
28415                 false,
28416         },
28417         {
28418                 "spoolss_5f",
28419                 sizeof(struct spoolss_5f),
28420                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28422                 (ndr_print_function_t) ndr_print_spoolss_5f,
28423                 false,
28424         },
28425         { NULL, 0, NULL, NULL, NULL, false }
28426 };
28427
28428 static const char * const spoolss_endpoint_strings[] = {
28429         "ncacn_np:[\\pipe\\spoolss]",
28430 };
28431
28432 static const struct ndr_interface_string_array spoolss_endpoints = {
28433         .count  = 1,
28434         .names  = spoolss_endpoint_strings
28435 };
28436
28437 static const char * const spoolss_authservice_strings[] = {
28438         "host",
28439 };
28440
28441 static const struct ndr_interface_string_array spoolss_authservices = {
28442         .count  = 1,
28443         .names  = spoolss_authservice_strings
28444 };
28445
28446
28447 const struct ndr_interface_table ndr_table_spoolss = {
28448         .name           = "spoolss",
28449         .syntax_id      = {
28450                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28451                 NDR_SPOOLSS_VERSION
28452         },
28453         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28454         .num_calls      = 96,
28455         .calls          = spoolss_calls,
28456         .endpoints      = &spoolss_endpoints,
28457         .authservices   = &spoolss_authservices
28458 };
28459