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 static enum ndr_err_code ndr_push_spoolss_Field(struct ndr_push *ndr, int ndr_flags, enum spoolss_Field r)
16968 {
16969         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
16970         return NDR_ERR_SUCCESS;
16971 }
16972
16973 static enum ndr_err_code ndr_pull_spoolss_Field(struct ndr_pull *ndr, int ndr_flags, enum spoolss_Field *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_Field(struct ndr_print *ndr, const char *name, enum spoolss_Field r)
16982 {
16983         const char *val = NULL;
16984
16985         switch (r) {
16986                 case SPOOLSS_FIELD_SERVER_NAME: val = "SPOOLSS_FIELD_SERVER_NAME"; break;
16987                 case SPOOLSS_FIELD_PRINTER_NAME: val = "SPOOLSS_FIELD_PRINTER_NAME"; break;
16988                 case SPOOLSS_FIELD_SHARE_NAME: val = "SPOOLSS_FIELD_SHARE_NAME"; break;
16989                 case SPOOLSS_FIELD_PORT_NAME: val = "SPOOLSS_FIELD_PORT_NAME"; break;
16990                 case SPOOLSS_FIELD_DRIVER_NAME: val = "SPOOLSS_FIELD_DRIVER_NAME"; break;
16991                 case SPOOLSS_FIELD_COMMENT: val = "SPOOLSS_FIELD_COMMENT"; break;
16992                 case SPOOLSS_FIELD_LOCATION: val = "SPOOLSS_FIELD_LOCATION"; break;
16993                 case SPOOLSS_FIELD_DEVMODE: val = "SPOOLSS_FIELD_DEVMODE"; break;
16994                 case SPOOLSS_FIELD_SEPFILE: val = "SPOOLSS_FIELD_SEPFILE"; break;
16995                 case SPOOLSS_FIELD_PRINT_PROCESSOR: val = "SPOOLSS_FIELD_PRINT_PROCESSOR"; break;
16996                 case SPOOLSS_FIELD_PARAMETERS: val = "SPOOLSS_FIELD_PARAMETERS"; break;
16997                 case SPOOLSS_FIELD_DATATYPE: val = "SPOOLSS_FIELD_DATATYPE"; break;
16998                 case SPOOLSS_FIELD_SECURITY_DESCRIPTOR: val = "SPOOLSS_FIELD_SECURITY_DESCRIPTOR"; break;
16999                 case SPOOLSS_FIELD_ATTRIBUTES: val = "SPOOLSS_FIELD_ATTRIBUTES"; break;
17000                 case SPOOLSS_FIELD_PRIORITY: val = "SPOOLSS_FIELD_PRIORITY"; break;
17001                 case SPOOLSS_FIELD_DEFAULT_PRIORITY: val = "SPOOLSS_FIELD_DEFAULT_PRIORITY"; break;
17002                 case SPOOLSS_FIELD_START_TIME: val = "SPOOLSS_FIELD_START_TIME"; break;
17003                 case SPOOLSS_FIELD_UNTIL_TIME: val = "SPOOLSS_FIELD_UNTIL_TIME"; break;
17004                 case SPOOLSS_FIELD_STATUS: val = "SPOOLSS_FIELD_STATUS"; break;
17005                 case SPOOLSS_FIELD_STATUS_STRING: val = "SPOOLSS_FIELD_STATUS_STRING"; break;
17006                 case SPOOLSS_FIELD_CJOBS: val = "SPOOLSS_FIELD_CJOBS"; break;
17007                 case SPOOLSS_FIELD_AVERAGE_PPM: val = "SPOOLSS_FIELD_AVERAGE_PPM"; break;
17008                 case SPOOLSS_FIELD_TOTAL_PAGES: val = "SPOOLSS_FIELD_TOTAL_PAGES"; break;
17009                 case SPOOLSS_FIELD_PAGES_PRINTED: val = "SPOOLSS_FIELD_PAGES_PRINTED"; break;
17010                 case SPOOLSS_FIELD_TOTAL_BYTES: val = "SPOOLSS_FIELD_TOTAL_BYTES"; break;
17011                 case SPOOLSS_FIELD_BYTES_PRINTED: val = "SPOOLSS_FIELD_BYTES_PRINTED"; break;
17012         }
17013         ndr_print_enum(ndr, name, "ENUM", val, r);
17014 }
17015
17016 static enum ndr_err_code ndr_push_spoolss_NotifyType(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyType r)
17017 {
17018         NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r));
17019         return NDR_ERR_SUCCESS;
17020 }
17021
17022 static enum ndr_err_code ndr_pull_spoolss_NotifyType(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyType *r)
17023 {
17024         uint16_t v;
17025         NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &v));
17026         *r = v;
17027         return NDR_ERR_SUCCESS;
17028 }
17029
17030 _PUBLIC_ void ndr_print_spoolss_NotifyType(struct ndr_print *ndr, const char *name, enum spoolss_NotifyType r)
17031 {
17032         const char *val = NULL;
17033
17034         switch (r) {
17035                 case PRINTER_NOTIFY_TYPE: val = "PRINTER_NOTIFY_TYPE"; break;
17036                 case JOB_NOTIFY_TYPE: val = "JOB_NOTIFY_TYPE"; break;
17037         }
17038         ndr_print_enum(ndr, name, "ENUM", val, r);
17039 }
17040
17041 static enum ndr_err_code ndr_push_spoolss_NotifyOptionType(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOptionType *r)
17042 {
17043         uint32_t cntr_fields_1;
17044         if (ndr_flags & NDR_SCALARS) {
17045                 NDR_CHECK(ndr_push_align(ndr, 4));
17046                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17047                 NDR_CHECK(ndr_push_uint16(ndr, NDR_SCALARS, r->u1));
17048                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u2));
17049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->u3));
17050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17051                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->fields));
17052         }
17053         if (ndr_flags & NDR_BUFFERS) {
17054                 if (r->fields) {
17055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17056                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17057                                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->fields[cntr_fields_1]));
17058                         }
17059                 }
17060         }
17061         return NDR_ERR_SUCCESS;
17062 }
17063
17064 static enum ndr_err_code ndr_pull_spoolss_NotifyOptionType(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOptionType *r)
17065 {
17066         uint32_t _ptr_fields;
17067         uint32_t cntr_fields_1;
17068         TALLOC_CTX *_mem_save_fields_0;
17069         TALLOC_CTX *_mem_save_fields_1;
17070         if (ndr_flags & NDR_SCALARS) {
17071                 NDR_CHECK(ndr_pull_align(ndr, 4));
17072                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17073                 NDR_CHECK(ndr_pull_uint16(ndr, NDR_SCALARS, &r->u1));
17074                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u2));
17075                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->u3));
17076                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17077                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_fields));
17078                 if (_ptr_fields) {
17079                         NDR_PULL_ALLOC(ndr, r->fields);
17080                 } else {
17081                         r->fields = NULL;
17082                 }
17083         }
17084         if (ndr_flags & NDR_BUFFERS) {
17085                 if (r->fields) {
17086                         _mem_save_fields_0 = NDR_PULL_GET_MEM_CTX(ndr);
17087                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17088                         NDR_CHECK(ndr_pull_array_size(ndr, &r->fields));
17089                         NDR_PULL_ALLOC_N(ndr, r->fields, ndr_get_array_size(ndr, &r->fields));
17090                         _mem_save_fields_1 = NDR_PULL_GET_MEM_CTX(ndr);
17091                         NDR_PULL_SET_MEM_CTX(ndr, r->fields, 0);
17092                         for (cntr_fields_1 = 0; cntr_fields_1 < r->count; cntr_fields_1++) {
17093                                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->fields[cntr_fields_1]));
17094                         }
17095                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_1, 0);
17096                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_fields_0, 0);
17097                 }
17098                 if (r->fields) {
17099                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->fields, r->count));
17100                 }
17101         }
17102         return NDR_ERR_SUCCESS;
17103 }
17104
17105 _PUBLIC_ void ndr_print_spoolss_NotifyOptionType(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOptionType *r)
17106 {
17107         uint32_t cntr_fields_1;
17108         ndr_print_struct(ndr, name, "spoolss_NotifyOptionType");
17109         ndr->depth++;
17110         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17111         ndr_print_uint16(ndr, "u1", r->u1);
17112         ndr_print_uint32(ndr, "u2", r->u2);
17113         ndr_print_uint32(ndr, "u3", r->u3);
17114         ndr_print_uint32(ndr, "count", r->count);
17115         ndr_print_ptr(ndr, "fields", r->fields);
17116         ndr->depth++;
17117         if (r->fields) {
17118                 ndr->print(ndr, "%s: ARRAY(%d)", "fields", (int)r->count);
17119                 ndr->depth++;
17120                 for (cntr_fields_1=0;cntr_fields_1<r->count;cntr_fields_1++) {
17121                         char *idx_1=NULL;
17122                         if (asprintf(&idx_1, "[%d]", cntr_fields_1) != -1) {
17123                                 ndr_print_spoolss_Field(ndr, "fields", r->fields[cntr_fields_1]);
17124                                 free(idx_1);
17125                         }
17126                 }
17127                 ndr->depth--;
17128         }
17129         ndr->depth--;
17130         ndr->depth--;
17131 }
17132
17133 static enum ndr_err_code ndr_push_spoolssNotifyOptionFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17134 {
17135         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17136         return NDR_ERR_SUCCESS;
17137 }
17138
17139 static enum ndr_err_code ndr_pull_spoolssNotifyOptionFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17140 {
17141         uint32_t v;
17142         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17143         *r = v;
17144         return NDR_ERR_SUCCESS;
17145 }
17146
17147 _PUBLIC_ void ndr_print_spoolssNotifyOptionFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17148 {
17149         ndr_print_uint32(ndr, name, r);
17150         ndr->depth++;
17151         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_OPTIONS_REFRESH", PRINTER_NOTIFY_OPTIONS_REFRESH, r);
17152         ndr->depth--;
17153 }
17154
17155 static enum ndr_err_code ndr_push_spoolss_NotifyOption(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyOption *r)
17156 {
17157         uint32_t cntr_types_1;
17158         if (ndr_flags & NDR_SCALARS) {
17159                 NDR_CHECK(ndr_push_align(ndr, 4));
17160                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17161                 NDR_CHECK(ndr_push_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, r->flags));
17162                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17163                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->types));
17164         }
17165         if (ndr_flags & NDR_BUFFERS) {
17166                 if (r->types) {
17167                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17168                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17169                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17170                         }
17171                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17172                                 NDR_CHECK(ndr_push_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17173                         }
17174                 }
17175         }
17176         return NDR_ERR_SUCCESS;
17177 }
17178
17179 static enum ndr_err_code ndr_pull_spoolss_NotifyOption(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyOption *r)
17180 {
17181         uint32_t _ptr_types;
17182         uint32_t cntr_types_1;
17183         TALLOC_CTX *_mem_save_types_0;
17184         TALLOC_CTX *_mem_save_types_1;
17185         if (ndr_flags & NDR_SCALARS) {
17186                 NDR_CHECK(ndr_pull_align(ndr, 4));
17187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17188                 NDR_CHECK(ndr_pull_spoolssNotifyOptionFlags(ndr, NDR_SCALARS, &r->flags));
17189                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17190                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_types));
17191                 if (_ptr_types) {
17192                         NDR_PULL_ALLOC(ndr, r->types);
17193                 } else {
17194                         r->types = NULL;
17195                 }
17196         }
17197         if (ndr_flags & NDR_BUFFERS) {
17198                 if (r->types) {
17199                         _mem_save_types_0 = NDR_PULL_GET_MEM_CTX(ndr);
17200                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17201                         NDR_CHECK(ndr_pull_array_size(ndr, &r->types));
17202                         NDR_PULL_ALLOC_N(ndr, r->types, ndr_get_array_size(ndr, &r->types));
17203                         _mem_save_types_1 = NDR_PULL_GET_MEM_CTX(ndr);
17204                         NDR_PULL_SET_MEM_CTX(ndr, r->types, 0);
17205                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17206                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_SCALARS, &r->types[cntr_types_1]));
17207                         }
17208                         for (cntr_types_1 = 0; cntr_types_1 < r->count; cntr_types_1++) {
17209                                 NDR_CHECK(ndr_pull_spoolss_NotifyOptionType(ndr, NDR_BUFFERS, &r->types[cntr_types_1]));
17210                         }
17211                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_1, 0);
17212                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_types_0, 0);
17213                 }
17214                 if (r->types) {
17215                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->types, r->count));
17216                 }
17217         }
17218         return NDR_ERR_SUCCESS;
17219 }
17220
17221 _PUBLIC_ void ndr_print_spoolss_NotifyOption(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyOption *r)
17222 {
17223         uint32_t cntr_types_1;
17224         ndr_print_struct(ndr, name, "spoolss_NotifyOption");
17225         ndr->depth++;
17226         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17227         ndr_print_spoolssNotifyOptionFlags(ndr, "flags", r->flags);
17228         ndr_print_uint32(ndr, "count", r->count);
17229         ndr_print_ptr(ndr, "types", r->types);
17230         ndr->depth++;
17231         if (r->types) {
17232                 ndr->print(ndr, "%s: ARRAY(%d)", "types", (int)r->count);
17233                 ndr->depth++;
17234                 for (cntr_types_1=0;cntr_types_1<r->count;cntr_types_1++) {
17235                         char *idx_1=NULL;
17236                         if (asprintf(&idx_1, "[%d]", cntr_types_1) != -1) {
17237                                 ndr_print_spoolss_NotifyOptionType(ndr, "types", &r->types[cntr_types_1]);
17238                                 free(idx_1);
17239                         }
17240                 }
17241                 ndr->depth--;
17242         }
17243         ndr->depth--;
17244         ndr->depth--;
17245 }
17246
17247 static enum ndr_err_code ndr_push_spoolss_NotifyString(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyString *r)
17248 {
17249         if (ndr_flags & NDR_SCALARS) {
17250                 NDR_CHECK(ndr_push_align(ndr, 4));
17251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17252                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->string));
17253         }
17254         if (ndr_flags & NDR_BUFFERS) {
17255                 if (r->string) {
17256                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size / 2));
17257                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->string, r->size / 2, sizeof(uint16_t), CH_UTF16));
17258                 }
17259         }
17260         return NDR_ERR_SUCCESS;
17261 }
17262
17263 static enum ndr_err_code ndr_pull_spoolss_NotifyString(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyString *r)
17264 {
17265         uint32_t _ptr_string;
17266         TALLOC_CTX *_mem_save_string_0;
17267         if (ndr_flags & NDR_SCALARS) {
17268                 NDR_CHECK(ndr_pull_align(ndr, 4));
17269                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17270                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_string));
17271                 if (_ptr_string) {
17272                         NDR_PULL_ALLOC(ndr, r->string);
17273                 } else {
17274                         r->string = NULL;
17275                 }
17276         }
17277         if (ndr_flags & NDR_BUFFERS) {
17278                 if (r->string) {
17279                         _mem_save_string_0 = NDR_PULL_GET_MEM_CTX(ndr);
17280                         NDR_PULL_SET_MEM_CTX(ndr, r->string, 0);
17281                         NDR_CHECK(ndr_pull_array_size(ndr, &r->string));
17282                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->string, ndr_get_array_size(ndr, &r->string), sizeof(uint16_t), CH_UTF16));
17283                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_string_0, 0);
17284                 }
17285                 if (r->string) {
17286                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->string, r->size / 2));
17287                 }
17288         }
17289         return NDR_ERR_SUCCESS;
17290 }
17291
17292 _PUBLIC_ void ndr_print_spoolss_NotifyString(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyString *r)
17293 {
17294         ndr_print_struct(ndr, name, "spoolss_NotifyString");
17295         ndr->depth++;
17296         ndr_print_uint32(ndr, "size", r->size);
17297         ndr_print_ptr(ndr, "string", r->string);
17298         ndr->depth++;
17299         if (r->string) {
17300                 ndr_print_string(ndr, "string", r->string);
17301         }
17302         ndr->depth--;
17303         ndr->depth--;
17304 }
17305
17306 static enum ndr_err_code ndr_push_spoolss_NotifyTable(struct ndr_push *ndr, int ndr_flags, enum spoolss_NotifyTable r)
17307 {
17308         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17309         return NDR_ERR_SUCCESS;
17310 }
17311
17312 static enum ndr_err_code ndr_pull_spoolss_NotifyTable(struct ndr_pull *ndr, int ndr_flags, enum spoolss_NotifyTable *r)
17313 {
17314         uint32_t v;
17315         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17316         *r = v;
17317         return NDR_ERR_SUCCESS;
17318 }
17319
17320 _PUBLIC_ void ndr_print_spoolss_NotifyTable(struct ndr_print *ndr, const char *name, enum spoolss_NotifyTable r)
17321 {
17322         const char *val = NULL;
17323
17324         switch (r) {
17325                 case NOTIFY_TABLE_DWORD: val = "NOTIFY_TABLE_DWORD"; break;
17326                 case NOTIFY_TABLE_STRING: val = "NOTIFY_TABLE_STRING"; break;
17327                 case NOTIFY_TABLE_DEVMODE: val = "NOTIFY_TABLE_DEVMODE"; break;
17328                 case NOTIFY_TABLE_TIME: val = "NOTIFY_TABLE_TIME"; break;
17329                 case NOTIFY_TABLE_SECURITYDESCRIPTOR: val = "NOTIFY_TABLE_SECURITYDESCRIPTOR"; break;
17330         }
17331         ndr_print_enum(ndr, name, "ENUM", val, r);
17332 }
17333
17334 static enum ndr_err_code ndr_push_spoolss_NotifyData(struct ndr_push *ndr, int ndr_flags, const union spoolss_NotifyData *r)
17335 {
17336         if (ndr_flags & NDR_SCALARS) {
17337                 int level = ndr_push_get_switch_value(ndr, r);
17338                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17339                 switch (level) {
17340                         case 1: {
17341                                 uint32_t cntr_integer_0;
17342                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17343                                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->integer[cntr_integer_0]));
17344                                 }
17345                         break; }
17346
17347                         case 2: {
17348                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17349                         break; }
17350
17351                         case 3: {
17352                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17353                         break; }
17354
17355                         case 4: {
17356                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17357                         break; }
17358
17359                         case 5: {
17360                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17361                         break; }
17362
17363                         default:
17364                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17365                 }
17366         }
17367         if (ndr_flags & NDR_BUFFERS) {
17368                 int level = ndr_push_get_switch_value(ndr, r);
17369                 switch (level) {
17370                         case 1:
17371                         break;
17372
17373                         case 2:
17374                                 NDR_CHECK(ndr_push_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17375                         break;
17376
17377                         case 3:
17378                                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17379                         break;
17380
17381                         case 4:
17382                                 NDR_CHECK(ndr_push_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17383                         break;
17384
17385                         case 5:
17386                                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17387                         break;
17388
17389                         default:
17390                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17391                 }
17392         }
17393         return NDR_ERR_SUCCESS;
17394 }
17395
17396 static enum ndr_err_code ndr_pull_spoolss_NotifyData(struct ndr_pull *ndr, int ndr_flags, union spoolss_NotifyData *r)
17397 {
17398         int level;
17399         uint32_t _level;
17400         level = ndr_pull_get_switch_value(ndr, r);
17401         if (ndr_flags & NDR_SCALARS) {
17402                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17403                 if (_level != level) {
17404                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17405                 }
17406                 switch (level) {
17407                         case 1: {
17408                                 uint32_t cntr_integer_0;
17409                                 for (cntr_integer_0 = 0; cntr_integer_0 < 2; cntr_integer_0++) {
17410                                         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->integer[cntr_integer_0]));
17411                                 }
17412                         break; }
17413
17414                         case 2: {
17415                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_SCALARS, &r->string));
17416                         break; }
17417
17418                         case 3: {
17419                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS, &r->devmode));
17420                         break; }
17421
17422                         case 4: {
17423                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_SCALARS, &r->time));
17424                         break; }
17425
17426                         case 5: {
17427                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS, &r->sd));
17428                         break; }
17429
17430                         default:
17431                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17432                 }
17433         }
17434         if (ndr_flags & NDR_BUFFERS) {
17435                 switch (level) {
17436                         case 1:
17437                         break;
17438
17439                         case 2:
17440                                 NDR_CHECK(ndr_pull_spoolss_NotifyString(ndr, NDR_BUFFERS, &r->string));
17441                         break;
17442
17443                         case 3:
17444                                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_BUFFERS, &r->devmode));
17445                         break;
17446
17447                         case 4:
17448                                 NDR_CHECK(ndr_pull_spoolss_TimeCtr(ndr, NDR_BUFFERS, &r->time));
17449                         break;
17450
17451                         case 5:
17452                                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_BUFFERS, &r->sd));
17453                         break;
17454
17455                         default:
17456                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17457                 }
17458         }
17459         return NDR_ERR_SUCCESS;
17460 }
17461
17462 _PUBLIC_ void ndr_print_spoolss_NotifyData(struct ndr_print *ndr, const char *name, const union spoolss_NotifyData *r)
17463 {
17464         int level;
17465         uint32_t cntr_integer_0;
17466         level = ndr_print_get_switch_value(ndr, r);
17467         ndr_print_union(ndr, name, level, "spoolss_NotifyData");
17468         switch (level) {
17469                 case 1:
17470                         ndr->print(ndr, "%s: ARRAY(%d)", "integer", (int)2);
17471                         ndr->depth++;
17472                         for (cntr_integer_0=0;cntr_integer_0<2;cntr_integer_0++) {
17473                                 char *idx_0=NULL;
17474                                 if (asprintf(&idx_0, "[%d]", cntr_integer_0) != -1) {
17475                                         ndr_print_uint32(ndr, "integer", r->integer[cntr_integer_0]);
17476                                         free(idx_0);
17477                                 }
17478                         }
17479                         ndr->depth--;
17480                 break;
17481
17482                 case 2:
17483                         ndr_print_spoolss_NotifyString(ndr, "string", &r->string);
17484                 break;
17485
17486                 case 3:
17487                         ndr_print_spoolss_DevmodeContainer(ndr, "devmode", &r->devmode);
17488                 break;
17489
17490                 case 4:
17491                         ndr_print_spoolss_TimeCtr(ndr, "time", &r->time);
17492                 break;
17493
17494                 case 5:
17495                         ndr_print_sec_desc_buf(ndr, "sd", &r->sd);
17496                 break;
17497
17498                 default:
17499                         ndr_print_bad_level(ndr, name, level);
17500         }
17501 }
17502
17503 static enum ndr_err_code ndr_push_spoolss_Notify(struct ndr_push *ndr, int ndr_flags, const struct spoolss_Notify *r)
17504 {
17505         if (ndr_flags & NDR_SCALARS) {
17506                 NDR_CHECK(ndr_push_align(ndr, 4));
17507                 NDR_CHECK(ndr_push_spoolss_NotifyType(ndr, NDR_SCALARS, r->type));
17508                 NDR_CHECK(ndr_push_spoolss_Field(ndr, NDR_SCALARS, r->field));
17509                 NDR_CHECK(ndr_push_spoolss_NotifyTable(ndr, NDR_SCALARS, r->variable_type));
17510                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->job_id));
17511                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->data, r->variable_type));
17512                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17513         }
17514         if (ndr_flags & NDR_BUFFERS) {
17515                 NDR_CHECK(ndr_push_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17516         }
17517         return NDR_ERR_SUCCESS;
17518 }
17519
17520 static enum ndr_err_code ndr_pull_spoolss_Notify(struct ndr_pull *ndr, int ndr_flags, struct spoolss_Notify *r)
17521 {
17522         if (ndr_flags & NDR_SCALARS) {
17523                 NDR_CHECK(ndr_pull_align(ndr, 4));
17524                 NDR_CHECK(ndr_pull_spoolss_NotifyType(ndr, NDR_SCALARS, &r->type));
17525                 NDR_CHECK(ndr_pull_spoolss_Field(ndr, NDR_SCALARS, &r->field));
17526                 NDR_CHECK(ndr_pull_spoolss_NotifyTable(ndr, NDR_SCALARS, &r->variable_type));
17527                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->job_id));
17528                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->data, r->variable_type));
17529                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_SCALARS, &r->data));
17530         }
17531         if (ndr_flags & NDR_BUFFERS) {
17532                 NDR_CHECK(ndr_pull_spoolss_NotifyData(ndr, NDR_BUFFERS, &r->data));
17533         }
17534         return NDR_ERR_SUCCESS;
17535 }
17536
17537 _PUBLIC_ void ndr_print_spoolss_Notify(struct ndr_print *ndr, const char *name, const struct spoolss_Notify *r)
17538 {
17539         ndr_print_struct(ndr, name, "spoolss_Notify");
17540         ndr->depth++;
17541         ndr_print_spoolss_NotifyType(ndr, "type", r->type);
17542         ndr_print_spoolss_Field(ndr, "field", r->field);
17543         ndr_print_spoolss_NotifyTable(ndr, "variable_type", r->variable_type);
17544         ndr_print_uint32(ndr, "job_id", r->job_id);
17545         ndr_print_set_switch_value(ndr, &r->data, r->variable_type);
17546         ndr_print_spoolss_NotifyData(ndr, "data", &r->data);
17547         ndr->depth--;
17548 }
17549
17550 static enum ndr_err_code ndr_push_spoolss_NotifyInfo(struct ndr_push *ndr, int ndr_flags, const struct spoolss_NotifyInfo *r)
17551 {
17552         uint32_t cntr_notifies_0;
17553         if (ndr_flags & NDR_SCALARS) {
17554                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17555                 NDR_CHECK(ndr_push_align(ndr, 4));
17556                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 2));
17557                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17558                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->count));
17559                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17560                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17561                 }
17562         }
17563         if (ndr_flags & NDR_BUFFERS) {
17564                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17565                         NDR_CHECK(ndr_push_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17566                 }
17567         }
17568         return NDR_ERR_SUCCESS;
17569 }
17570
17571 static enum ndr_err_code ndr_pull_spoolss_NotifyInfo(struct ndr_pull *ndr, int ndr_flags, struct spoolss_NotifyInfo *r)
17572 {
17573         uint32_t cntr_notifies_0;
17574         TALLOC_CTX *_mem_save_notifies_0;
17575         if (ndr_flags & NDR_SCALARS) {
17576                 NDR_CHECK(ndr_pull_array_size(ndr, &r->notifies));
17577                 NDR_CHECK(ndr_pull_align(ndr, 4));
17578                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
17579                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->count));
17581                 NDR_PULL_ALLOC_N(ndr, r->notifies, ndr_get_array_size(ndr, &r->notifies));
17582                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17583                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17584                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17585                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_SCALARS, &r->notifies[cntr_notifies_0]));
17586                 }
17587                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17588                 if (r->notifies) {
17589                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->notifies, r->count));
17590                 }
17591         }
17592         if (ndr_flags & NDR_BUFFERS) {
17593                 _mem_save_notifies_0 = NDR_PULL_GET_MEM_CTX(ndr);
17594                 NDR_PULL_SET_MEM_CTX(ndr, r->notifies, 0);
17595                 for (cntr_notifies_0 = 0; cntr_notifies_0 < r->count; cntr_notifies_0++) {
17596                         NDR_CHECK(ndr_pull_spoolss_Notify(ndr, NDR_BUFFERS, &r->notifies[cntr_notifies_0]));
17597                 }
17598                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notifies_0, 0);
17599         }
17600         return NDR_ERR_SUCCESS;
17601 }
17602
17603 _PUBLIC_ void ndr_print_spoolss_NotifyInfo(struct ndr_print *ndr, const char *name, const struct spoolss_NotifyInfo *r)
17604 {
17605         uint32_t cntr_notifies_0;
17606         ndr_print_struct(ndr, name, "spoolss_NotifyInfo");
17607         ndr->depth++;
17608         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?2:r->version);
17609         ndr_print_uint32(ndr, "flags", r->flags);
17610         ndr_print_uint32(ndr, "count", r->count);
17611         ndr->print(ndr, "%s: ARRAY(%d)", "notifies", (int)r->count);
17612         ndr->depth++;
17613         for (cntr_notifies_0=0;cntr_notifies_0<r->count;cntr_notifies_0++) {
17614                 char *idx_0=NULL;
17615                 if (asprintf(&idx_0, "[%d]", cntr_notifies_0) != -1) {
17616                         ndr_print_spoolss_Notify(ndr, "notifies", &r->notifies[cntr_notifies_0]);
17617                         free(idx_0);
17618                 }
17619         }
17620         ndr->depth--;
17621         ndr->depth--;
17622 }
17623
17624 static enum ndr_err_code ndr_push_spoolss_ReplyPrinterInfo(struct ndr_push *ndr, int ndr_flags, const union spoolss_ReplyPrinterInfo *r)
17625 {
17626         if (ndr_flags & NDR_SCALARS) {
17627                 int level = ndr_push_get_switch_value(ndr, r);
17628                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
17629                 switch (level) {
17630                         case 0: {
17631                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->info0));
17632                         break; }
17633
17634                         default:
17635                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17636                 }
17637         }
17638         if (ndr_flags & NDR_BUFFERS) {
17639                 int level = ndr_push_get_switch_value(ndr, r);
17640                 switch (level) {
17641                         case 0:
17642                                 if (r->info0) {
17643                                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17644                                 }
17645                         break;
17646
17647                         default:
17648                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17649                 }
17650         }
17651         return NDR_ERR_SUCCESS;
17652 }
17653
17654 static enum ndr_err_code ndr_pull_spoolss_ReplyPrinterInfo(struct ndr_pull *ndr, int ndr_flags, union spoolss_ReplyPrinterInfo *r)
17655 {
17656         int level;
17657         uint32_t _level;
17658         TALLOC_CTX *_mem_save_info0_0;
17659         level = ndr_pull_get_switch_value(ndr, r);
17660         if (ndr_flags & NDR_SCALARS) {
17661                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
17662                 if (_level != level) {
17663                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
17664                 }
17665                 switch (level) {
17666                         case 0: {
17667                                 uint32_t _ptr_info0;
17668                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info0));
17669                                 if (_ptr_info0) {
17670                                         NDR_PULL_ALLOC(ndr, r->info0);
17671                                 } else {
17672                                         r->info0 = NULL;
17673                                 }
17674                         break; }
17675
17676                         default:
17677                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17678                 }
17679         }
17680         if (ndr_flags & NDR_BUFFERS) {
17681                 switch (level) {
17682                         case 0:
17683                                 if (r->info0) {
17684                                         _mem_save_info0_0 = NDR_PULL_GET_MEM_CTX(ndr);
17685                                         NDR_PULL_SET_MEM_CTX(ndr, r->info0, 0);
17686                                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, r->info0));
17687                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info0_0, 0);
17688                                 }
17689                         break;
17690
17691                         default:
17692                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
17693                 }
17694         }
17695         return NDR_ERR_SUCCESS;
17696 }
17697
17698 _PUBLIC_ void ndr_print_spoolss_ReplyPrinterInfo(struct ndr_print *ndr, const char *name, const union spoolss_ReplyPrinterInfo *r)
17699 {
17700         int level;
17701         level = ndr_print_get_switch_value(ndr, r);
17702         ndr_print_union(ndr, name, level, "spoolss_ReplyPrinterInfo");
17703         switch (level) {
17704                 case 0:
17705                         ndr_print_ptr(ndr, "info0", r->info0);
17706                         ndr->depth++;
17707                         if (r->info0) {
17708                                 ndr_print_spoolss_NotifyInfo(ndr, "info0", r->info0);
17709                         }
17710                         ndr->depth--;
17711                 break;
17712
17713                 default:
17714                         ndr_print_bad_level(ndr, name, level);
17715         }
17716 }
17717
17718 static enum ndr_err_code ndr_push_spoolss_PrinterNotifyFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
17719 {
17720         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
17721         return NDR_ERR_SUCCESS;
17722 }
17723
17724 static enum ndr_err_code ndr_pull_spoolss_PrinterNotifyFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
17725 {
17726         uint32_t v;
17727         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
17728         *r = v;
17729         return NDR_ERR_SUCCESS;
17730 }
17731
17732 _PUBLIC_ void ndr_print_spoolss_PrinterNotifyFlags(struct ndr_print *ndr, const char *name, uint32_t r)
17733 {
17734         ndr_print_uint32(ndr, name, r);
17735         ndr->depth++;
17736         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDED", PRINTER_NOTIFY_INFO_DISCARDED, r);
17737         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_DISCARDNOTED", PRINTER_NOTIFY_INFO_DISCARDNOTED, r);
17738         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_NOTIFY_INFO_COLOR_MISMATCH", PRINTER_NOTIFY_INFO_COLOR_MISMATCH, r);
17739         ndr->depth--;
17740 }
17741
17742 static enum ndr_err_code ndr_push_spoolss_UserLevel1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel1 *r)
17743 {
17744         if (ndr_flags & NDR_SCALARS) {
17745                 NDR_CHECK(ndr_push_align(ndr, 4));
17746                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17747                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17748                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17749                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17750                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17751                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17752                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17753         }
17754         if (ndr_flags & NDR_BUFFERS) {
17755                 if (r->client) {
17756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17757                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17758                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17759                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17760                 }
17761                 if (r->user) {
17762                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17763                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17764                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17765                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17766                 }
17767         }
17768         return NDR_ERR_SUCCESS;
17769 }
17770
17771 static enum ndr_err_code ndr_pull_spoolss_UserLevel1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel1 *r)
17772 {
17773         uint32_t _ptr_client;
17774         TALLOC_CTX *_mem_save_client_0;
17775         uint32_t _ptr_user;
17776         TALLOC_CTX *_mem_save_user_0;
17777         if (ndr_flags & NDR_SCALARS) {
17778                 NDR_CHECK(ndr_pull_align(ndr, 4));
17779                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17780                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17781                 if (_ptr_client) {
17782                         NDR_PULL_ALLOC(ndr, r->client);
17783                 } else {
17784                         r->client = NULL;
17785                 }
17786                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17787                 if (_ptr_user) {
17788                         NDR_PULL_ALLOC(ndr, r->user);
17789                 } else {
17790                         r->user = NULL;
17791                 }
17792                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17793                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17794                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17795                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17796         }
17797         if (ndr_flags & NDR_BUFFERS) {
17798                 if (r->client) {
17799                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17800                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17801                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17802                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17803                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17804                                 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));
17805                         }
17806                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17807                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17808                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17809                 }
17810                 if (r->user) {
17811                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17812                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17813                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17814                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17815                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17816                                 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));
17817                         }
17818                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17819                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17820                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17821                 }
17822         }
17823         return NDR_ERR_SUCCESS;
17824 }
17825
17826 _PUBLIC_ void ndr_print_spoolss_UserLevel1(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel1 *r)
17827 {
17828         ndr_print_struct(ndr, name, "spoolss_UserLevel1");
17829         ndr->depth++;
17830         ndr_print_uint32(ndr, "size", r->size);
17831         ndr_print_ptr(ndr, "client", r->client);
17832         ndr->depth++;
17833         if (r->client) {
17834                 ndr_print_string(ndr, "client", r->client);
17835         }
17836         ndr->depth--;
17837         ndr_print_ptr(ndr, "user", r->user);
17838         ndr->depth++;
17839         if (r->user) {
17840                 ndr_print_string(ndr, "user", r->user);
17841         }
17842         ndr->depth--;
17843         ndr_print_uint32(ndr, "build", r->build);
17844         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17845         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17846         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17847         ndr->depth--;
17848 }
17849
17850 static enum ndr_err_code ndr_push_spoolss_UserLevel2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel2 *r)
17851 {
17852         if (ndr_flags & NDR_SCALARS) {
17853                 NDR_CHECK(ndr_push_align(ndr, 4));
17854                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->not_used));
17855         }
17856         if (ndr_flags & NDR_BUFFERS) {
17857         }
17858         return NDR_ERR_SUCCESS;
17859 }
17860
17861 static enum ndr_err_code ndr_pull_spoolss_UserLevel2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel2 *r)
17862 {
17863         if (ndr_flags & NDR_SCALARS) {
17864                 NDR_CHECK(ndr_pull_align(ndr, 4));
17865                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->not_used));
17866         }
17867         if (ndr_flags & NDR_BUFFERS) {
17868         }
17869         return NDR_ERR_SUCCESS;
17870 }
17871
17872 _PUBLIC_ void ndr_print_spoolss_UserLevel2(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel2 *r)
17873 {
17874         ndr_print_struct(ndr, name, "spoolss_UserLevel2");
17875         ndr->depth++;
17876         ndr_print_uint32(ndr, "not_used", r->not_used);
17877         ndr->depth--;
17878 }
17879
17880 static enum ndr_err_code ndr_push_spoolss_UserLevel3(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevel3 *r)
17881 {
17882         if (ndr_flags & NDR_SCALARS) {
17883                 NDR_CHECK(ndr_push_align(ndr, 4));
17884                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size));
17885                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->flags));
17886                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->size2));
17887                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->client));
17888                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->user));
17889                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->build));
17890                 NDR_CHECK(ndr_push_spoolss_MajorVersion(ndr, NDR_SCALARS, r->major));
17891                 NDR_CHECK(ndr_push_spoolss_MinorVersion(ndr, NDR_SCALARS, r->minor));
17892                 NDR_CHECK(ndr_push_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, r->processor));
17893                 NDR_CHECK(ndr_push_udlong(ndr, NDR_SCALARS, r->reserved));
17894         }
17895         if (ndr_flags & NDR_BUFFERS) {
17896                 if (r->client) {
17897                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17898                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17899                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->client, CH_UTF16)));
17900                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->client, ndr_charset_length(r->client, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17901                 }
17902                 if (r->user) {
17903                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17904                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
17905                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->user, CH_UTF16)));
17906                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->user, ndr_charset_length(r->user, CH_UTF16), sizeof(uint16_t), CH_UTF16));
17907                 }
17908         }
17909         return NDR_ERR_SUCCESS;
17910 }
17911
17912 static enum ndr_err_code ndr_pull_spoolss_UserLevel3(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevel3 *r)
17913 {
17914         uint32_t _ptr_client;
17915         TALLOC_CTX *_mem_save_client_0;
17916         uint32_t _ptr_user;
17917         TALLOC_CTX *_mem_save_user_0;
17918         if (ndr_flags & NDR_SCALARS) {
17919                 NDR_CHECK(ndr_pull_align(ndr, 4));
17920                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
17921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->flags));
17922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size2));
17923                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_client));
17924                 if (_ptr_client) {
17925                         NDR_PULL_ALLOC(ndr, r->client);
17926                 } else {
17927                         r->client = NULL;
17928                 }
17929                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_user));
17930                 if (_ptr_user) {
17931                         NDR_PULL_ALLOC(ndr, r->user);
17932                 } else {
17933                         r->user = NULL;
17934                 }
17935                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->build));
17936                 NDR_CHECK(ndr_pull_spoolss_MajorVersion(ndr, NDR_SCALARS, &r->major));
17937                 NDR_CHECK(ndr_pull_spoolss_MinorVersion(ndr, NDR_SCALARS, &r->minor));
17938                 NDR_CHECK(ndr_pull_spoolss_ProcessorArchitecture(ndr, NDR_SCALARS, &r->processor));
17939                 NDR_CHECK(ndr_pull_udlong(ndr, NDR_SCALARS, &r->reserved));
17940         }
17941         if (ndr_flags & NDR_BUFFERS) {
17942                 if (r->client) {
17943                         _mem_save_client_0 = NDR_PULL_GET_MEM_CTX(ndr);
17944                         NDR_PULL_SET_MEM_CTX(ndr, r->client, 0);
17945                         NDR_CHECK(ndr_pull_array_size(ndr, &r->client));
17946                         NDR_CHECK(ndr_pull_array_length(ndr, &r->client));
17947                         if (ndr_get_array_length(ndr, &r->client) > ndr_get_array_size(ndr, &r->client)) {
17948                                 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));
17949                         }
17950                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t)));
17951                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->client, ndr_get_array_length(ndr, &r->client), sizeof(uint16_t), CH_UTF16));
17952                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_client_0, 0);
17953                 }
17954                 if (r->user) {
17955                         _mem_save_user_0 = NDR_PULL_GET_MEM_CTX(ndr);
17956                         NDR_PULL_SET_MEM_CTX(ndr, r->user, 0);
17957                         NDR_CHECK(ndr_pull_array_size(ndr, &r->user));
17958                         NDR_CHECK(ndr_pull_array_length(ndr, &r->user));
17959                         if (ndr_get_array_length(ndr, &r->user) > ndr_get_array_size(ndr, &r->user)) {
17960                                 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));
17961                         }
17962                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t)));
17963                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->user, ndr_get_array_length(ndr, &r->user), sizeof(uint16_t), CH_UTF16));
17964                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_user_0, 0);
17965                 }
17966         }
17967         return NDR_ERR_SUCCESS;
17968 }
17969
17970 _PUBLIC_ void ndr_print_spoolss_UserLevel3(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevel3 *r)
17971 {
17972         ndr_print_struct(ndr, name, "spoolss_UserLevel3");
17973         ndr->depth++;
17974         ndr_print_uint32(ndr, "size", r->size);
17975         ndr_print_uint32(ndr, "flags", r->flags);
17976         ndr_print_uint32(ndr, "size2", r->size2);
17977         ndr_print_ptr(ndr, "client", r->client);
17978         ndr->depth++;
17979         if (r->client) {
17980                 ndr_print_string(ndr, "client", r->client);
17981         }
17982         ndr->depth--;
17983         ndr_print_ptr(ndr, "user", r->user);
17984         ndr->depth++;
17985         if (r->user) {
17986                 ndr_print_string(ndr, "user", r->user);
17987         }
17988         ndr->depth--;
17989         ndr_print_uint32(ndr, "build", r->build);
17990         ndr_print_spoolss_MajorVersion(ndr, "major", r->major);
17991         ndr_print_spoolss_MinorVersion(ndr, "minor", r->minor);
17992         ndr_print_spoolss_ProcessorArchitecture(ndr, "processor", r->processor);
17993         ndr_print_udlong(ndr, "reserved", r->reserved);
17994         ndr->depth--;
17995 }
17996
17997 static enum ndr_err_code ndr_push_spoolss_UserLevel(struct ndr_push *ndr, int ndr_flags, const union spoolss_UserLevel *r)
17998 {
17999         if (ndr_flags & NDR_SCALARS) {
18000                 int level = ndr_push_get_switch_value(ndr, r);
18001                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, level));
18002                 switch (level) {
18003                         case 1: {
18004                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level1));
18005                         break; }
18006
18007                         case 2: {
18008                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level2));
18009                         break; }
18010
18011                         case 3: {
18012                                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->level3));
18013                         break; }
18014
18015                         default:
18016                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18017                 }
18018         }
18019         if (ndr_flags & NDR_BUFFERS) {
18020                 int level = ndr_push_get_switch_value(ndr, r);
18021                 switch (level) {
18022                         case 1:
18023                                 if (r->level1) {
18024                                         NDR_CHECK(ndr_push_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18025                                 }
18026                         break;
18027
18028                         case 2:
18029                                 if (r->level2) {
18030                                         NDR_CHECK(ndr_push_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18031                                 }
18032                         break;
18033
18034                         case 3:
18035                                 if (r->level3) {
18036                                         NDR_CHECK(ndr_push_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18037                                 }
18038                         break;
18039
18040                         default:
18041                                 return ndr_push_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18042                 }
18043         }
18044         return NDR_ERR_SUCCESS;
18045 }
18046
18047 static enum ndr_err_code ndr_pull_spoolss_UserLevel(struct ndr_pull *ndr, int ndr_flags, union spoolss_UserLevel *r)
18048 {
18049         int level;
18050         uint32_t _level;
18051         TALLOC_CTX *_mem_save_level1_0;
18052         TALLOC_CTX *_mem_save_level2_0;
18053         TALLOC_CTX *_mem_save_level3_0;
18054         level = ndr_pull_get_switch_value(ndr, r);
18055         if (ndr_flags & NDR_SCALARS) {
18056                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &_level));
18057                 if (_level != level) {
18058                         return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u for r", _level);
18059                 }
18060                 switch (level) {
18061                         case 1: {
18062                                 uint32_t _ptr_level1;
18063                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level1));
18064                                 if (_ptr_level1) {
18065                                         NDR_PULL_ALLOC(ndr, r->level1);
18066                                 } else {
18067                                         r->level1 = NULL;
18068                                 }
18069                         break; }
18070
18071                         case 2: {
18072                                 uint32_t _ptr_level2;
18073                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level2));
18074                                 if (_ptr_level2) {
18075                                         NDR_PULL_ALLOC(ndr, r->level2);
18076                                 } else {
18077                                         r->level2 = NULL;
18078                                 }
18079                         break; }
18080
18081                         case 3: {
18082                                 uint32_t _ptr_level3;
18083                                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_level3));
18084                                 if (_ptr_level3) {
18085                                         NDR_PULL_ALLOC(ndr, r->level3);
18086                                 } else {
18087                                         r->level3 = NULL;
18088                                 }
18089                         break; }
18090
18091                         default:
18092                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18093                 }
18094         }
18095         if (ndr_flags & NDR_BUFFERS) {
18096                 switch (level) {
18097                         case 1:
18098                                 if (r->level1) {
18099                                         _mem_save_level1_0 = NDR_PULL_GET_MEM_CTX(ndr);
18100                                         NDR_PULL_SET_MEM_CTX(ndr, r->level1, 0);
18101                                         NDR_CHECK(ndr_pull_spoolss_UserLevel1(ndr, NDR_SCALARS|NDR_BUFFERS, r->level1));
18102                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level1_0, 0);
18103                                 }
18104                         break;
18105
18106                         case 2:
18107                                 if (r->level2) {
18108                                         _mem_save_level2_0 = NDR_PULL_GET_MEM_CTX(ndr);
18109                                         NDR_PULL_SET_MEM_CTX(ndr, r->level2, 0);
18110                                         NDR_CHECK(ndr_pull_spoolss_UserLevel2(ndr, NDR_SCALARS, r->level2));
18111                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level2_0, 0);
18112                                 }
18113                         break;
18114
18115                         case 3:
18116                                 if (r->level3) {
18117                                         _mem_save_level3_0 = NDR_PULL_GET_MEM_CTX(ndr);
18118                                         NDR_PULL_SET_MEM_CTX(ndr, r->level3, 0);
18119                                         NDR_CHECK(ndr_pull_spoolss_UserLevel3(ndr, NDR_SCALARS|NDR_BUFFERS, r->level3));
18120                                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_level3_0, 0);
18121                                 }
18122                         break;
18123
18124                         default:
18125                                 return ndr_pull_error(ndr, NDR_ERR_BAD_SWITCH, "Bad switch value %u", level);
18126                 }
18127         }
18128         return NDR_ERR_SUCCESS;
18129 }
18130
18131 _PUBLIC_ void ndr_print_spoolss_UserLevel(struct ndr_print *ndr, const char *name, const union spoolss_UserLevel *r)
18132 {
18133         int level;
18134         level = ndr_print_get_switch_value(ndr, r);
18135         ndr_print_union(ndr, name, level, "spoolss_UserLevel");
18136         switch (level) {
18137                 case 1:
18138                         ndr_print_ptr(ndr, "level1", r->level1);
18139                         ndr->depth++;
18140                         if (r->level1) {
18141                                 ndr_print_spoolss_UserLevel1(ndr, "level1", r->level1);
18142                         }
18143                         ndr->depth--;
18144                 break;
18145
18146                 case 2:
18147                         ndr_print_ptr(ndr, "level2", r->level2);
18148                         ndr->depth++;
18149                         if (r->level2) {
18150                                 ndr_print_spoolss_UserLevel2(ndr, "level2", r->level2);
18151                         }
18152                         ndr->depth--;
18153                 break;
18154
18155                 case 3:
18156                         ndr_print_ptr(ndr, "level3", r->level3);
18157                         ndr->depth++;
18158                         if (r->level3) {
18159                                 ndr_print_spoolss_UserLevel3(ndr, "level3", r->level3);
18160                         }
18161                         ndr->depth--;
18162                 break;
18163
18164                 default:
18165                         ndr_print_bad_level(ndr, name, level);
18166         }
18167 }
18168
18169 static enum ndr_err_code ndr_push_spoolss_UserLevelCtr(struct ndr_push *ndr, int ndr_flags, const struct spoolss_UserLevelCtr *r)
18170 {
18171         if (ndr_flags & NDR_SCALARS) {
18172                 NDR_CHECK(ndr_push_align(ndr, 4));
18173                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->level));
18174                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->user_info, r->level));
18175                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18176         }
18177         if (ndr_flags & NDR_BUFFERS) {
18178                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18179         }
18180         return NDR_ERR_SUCCESS;
18181 }
18182
18183 static enum ndr_err_code ndr_pull_spoolss_UserLevelCtr(struct ndr_pull *ndr, int ndr_flags, struct spoolss_UserLevelCtr *r)
18184 {
18185         if (ndr_flags & NDR_SCALARS) {
18186                 NDR_CHECK(ndr_pull_align(ndr, 4));
18187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->level));
18188                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->user_info, r->level));
18189                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS, &r->user_info));
18190         }
18191         if (ndr_flags & NDR_BUFFERS) {
18192                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_BUFFERS, &r->user_info));
18193         }
18194         return NDR_ERR_SUCCESS;
18195 }
18196
18197 _PUBLIC_ void ndr_print_spoolss_UserLevelCtr(struct ndr_print *ndr, const char *name, const struct spoolss_UserLevelCtr *r)
18198 {
18199         ndr_print_struct(ndr, name, "spoolss_UserLevelCtr");
18200         ndr->depth++;
18201         ndr_print_uint32(ndr, "level", r->level);
18202         ndr_print_set_switch_value(ndr, &r->user_info, r->level);
18203         ndr_print_spoolss_UserLevel(ndr, "user_info", &r->user_info);
18204         ndr->depth--;
18205 }
18206
18207 static enum ndr_err_code ndr_push_spoolss_AccessRights(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18208 {
18209         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18210         return NDR_ERR_SUCCESS;
18211 }
18212
18213 static enum ndr_err_code ndr_pull_spoolss_AccessRights(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18214 {
18215         uint32_t v;
18216         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18217         *r = v;
18218         return NDR_ERR_SUCCESS;
18219 }
18220
18221 _PUBLIC_ void ndr_print_spoolss_AccessRights(struct ndr_print *ndr, const char *name, uint32_t r)
18222 {
18223         ndr_print_uint32(ndr, name, r);
18224         ndr->depth++;
18225         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ADMINISTER", SERVER_ACCESS_ADMINISTER, r);
18226         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "SERVER_ACCESS_ENUMERATE", SERVER_ACCESS_ENUMERATE, r);
18227         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_ADMINISTER", PRINTER_ACCESS_ADMINISTER, r);
18228         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "PRINTER_ACCESS_USE", PRINTER_ACCESS_USE, r);
18229         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_ADMINISTER", JOB_ACCESS_ADMINISTER, r);
18230         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "JOB_ACCESS_READ", JOB_ACCESS_READ, r);
18231         ndr->depth--;
18232 }
18233
18234 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_DeleteDriverFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18235 {
18236         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18237         return NDR_ERR_SUCCESS;
18238 }
18239
18240 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_DeleteDriverFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18241 {
18242         uint32_t v;
18243         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18244         *r = v;
18245         return NDR_ERR_SUCCESS;
18246 }
18247
18248 _PUBLIC_ void ndr_print_spoolss_DeleteDriverFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18249 {
18250         ndr_print_uint32(ndr, name, r);
18251         ndr->depth++;
18252         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_UNUSED_FILES", DPD_DELETE_UNUSED_FILES, r);
18253         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_SPECIFIC_VERSION", DPD_DELETE_SPECIFIC_VERSION, r);
18254         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "DPD_DELETE_ALL_FILES", DPD_DELETE_ALL_FILES, r);
18255         ndr->depth--;
18256 }
18257
18258 static enum ndr_err_code ndr_push_spoolss_PortProtocol(struct ndr_push *ndr, int ndr_flags, enum spoolss_PortProtocol r)
18259 {
18260         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18261         return NDR_ERR_SUCCESS;
18262 }
18263
18264 static enum ndr_err_code ndr_pull_spoolss_PortProtocol(struct ndr_pull *ndr, int ndr_flags, enum spoolss_PortProtocol *r)
18265 {
18266         uint32_t v;
18267         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18268         *r = v;
18269         return NDR_ERR_SUCCESS;
18270 }
18271
18272 _PUBLIC_ void ndr_print_spoolss_PortProtocol(struct ndr_print *ndr, const char *name, enum spoolss_PortProtocol r)
18273 {
18274         const char *val = NULL;
18275
18276         switch (r) {
18277                 case PROTOCOL_RAWTCP_TYPE: val = "PROTOCOL_RAWTCP_TYPE"; break;
18278                 case PROTOCOL_LPR_TYPE: val = "PROTOCOL_LPR_TYPE"; break;
18279         }
18280         ndr_print_enum(ndr, name, "ENUM", val, r);
18281 }
18282
18283 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData1(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData1 *r)
18284 {
18285         if (ndr_flags & NDR_SCALARS) {
18286                 NDR_CHECK(ndr_push_align(ndr, 4));
18287                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18288                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000001));
18289                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18290                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18291                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18292                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18293                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18295                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18296                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18297                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18298                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18299                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18300                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18301                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18302         }
18303         if (ndr_flags & NDR_BUFFERS) {
18304         }
18305         return NDR_ERR_SUCCESS;
18306 }
18307
18308 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData1(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData1 *r)
18309 {
18310         if (ndr_flags & NDR_SCALARS) {
18311                 NDR_CHECK(ndr_pull_align(ndr, 4));
18312                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18313                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18314                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18315                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18316                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18317                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 49, sizeof(uint16_t), CH_UTF16));
18318                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18319                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18320                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18321                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->ip_address, 16, sizeof(uint16_t), CH_UTF16));
18322                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hardware_address, 13, sizeof(uint16_t), CH_UTF16));
18323                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18324                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18325                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18326                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18327         }
18328         if (ndr_flags & NDR_BUFFERS) {
18329         }
18330         return NDR_ERR_SUCCESS;
18331 }
18332
18333 _PUBLIC_ void ndr_print_spoolss_PortData1(struct ndr_print *ndr, const char *name, const struct spoolss_PortData1 *r)
18334 {
18335         ndr_print_struct(ndr, name, "spoolss_PortData1");
18336         ndr->depth++;
18337         ndr_print_string(ndr, "portname", r->portname);
18338         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000001:r->version);
18339         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18340         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18341         ndr_print_uint32(ndr, "reserved", r->reserved);
18342         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18343         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18344         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18345         ndr_print_string(ndr, "queue", r->queue);
18346         ndr_print_string(ndr, "ip_address", r->ip_address);
18347         ndr_print_string(ndr, "hardware_address", r->hardware_address);
18348         ndr_print_string(ndr, "device_type", r->device_type);
18349         ndr_print_uint32(ndr, "port_number", r->port_number);
18350         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18351         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18352         ndr->depth--;
18353 }
18354
18355 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_PortData2(struct ndr_push *ndr, int ndr_flags, const struct spoolss_PortData2 *r)
18356 {
18357         if (ndr_flags & NDR_SCALARS) {
18358                 NDR_CHECK(ndr_push_align(ndr, 4));
18359                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->portname, 64, sizeof(uint16_t), CH_UTF16));
18360                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0x00000002));
18361                 NDR_CHECK(ndr_push_spoolss_PortProtocol(ndr, NDR_SCALARS, r->protocol));
18362                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, sizeof(r)));
18363                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->reserved));
18364                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18365                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18366                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->dblspool));
18367                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->queue, 33, sizeof(uint16_t), CH_UTF16));
18368                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18369                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_number));
18370                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_enabled));
18371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->snmp_dev_index));
18372                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->port_monitor_mib_index));
18373         }
18374         if (ndr_flags & NDR_BUFFERS) {
18375         }
18376         return NDR_ERR_SUCCESS;
18377 }
18378
18379 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_PortData2(struct ndr_pull *ndr, int ndr_flags, struct spoolss_PortData2 *r)
18380 {
18381         if (ndr_flags & NDR_SCALARS) {
18382                 NDR_CHECK(ndr_pull_align(ndr, 4));
18383                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->portname, 64, sizeof(uint16_t), CH_UTF16));
18384                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->version));
18385                 NDR_CHECK(ndr_pull_spoolss_PortProtocol(ndr, NDR_SCALARS, &r->protocol));
18386                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->size));
18387                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->reserved));
18388                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->hostaddress, 128, sizeof(uint16_t), CH_UTF16));
18389                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->snmpcommunity, 33, sizeof(uint16_t), CH_UTF16));
18390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->dblspool));
18391                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->queue, 33, sizeof(uint16_t), CH_UTF16));
18392                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->device_type, 257, sizeof(uint16_t), CH_UTF16));
18393                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_number));
18394                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_enabled));
18395                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->snmp_dev_index));
18396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->port_monitor_mib_index));
18397         }
18398         if (ndr_flags & NDR_BUFFERS) {
18399         }
18400         return NDR_ERR_SUCCESS;
18401 }
18402
18403 _PUBLIC_ void ndr_print_spoolss_PortData2(struct ndr_print *ndr, const char *name, const struct spoolss_PortData2 *r)
18404 {
18405         ndr_print_struct(ndr, name, "spoolss_PortData2");
18406         ndr->depth++;
18407         ndr_print_string(ndr, "portname", r->portname);
18408         ndr_print_uint32(ndr, "version", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?0x00000002:r->version);
18409         ndr_print_spoolss_PortProtocol(ndr, "protocol", r->protocol);
18410         ndr_print_uint32(ndr, "size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?sizeof(r):r->size);
18411         ndr_print_uint32(ndr, "reserved", r->reserved);
18412         ndr_print_string(ndr, "hostaddress", r->hostaddress);
18413         ndr_print_string(ndr, "snmpcommunity", r->snmpcommunity);
18414         ndr_print_uint32(ndr, "dblspool", r->dblspool);
18415         ndr_print_string(ndr, "queue", r->queue);
18416         ndr_print_string(ndr, "device_type", r->device_type);
18417         ndr_print_uint32(ndr, "port_number", r->port_number);
18418         ndr_print_uint32(ndr, "snmp_enabled", r->snmp_enabled);
18419         ndr_print_uint32(ndr, "snmp_dev_index", r->snmp_dev_index);
18420         ndr_print_uint32(ndr, "port_monitor_mib_index", r->port_monitor_mib_index);
18421         ndr->depth--;
18422 }
18423
18424 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_MonitorUi(struct ndr_push *ndr, int ndr_flags, const struct spoolss_MonitorUi *r)
18425 {
18426         if (ndr_flags & NDR_SCALARS) {
18427                 NDR_CHECK(ndr_push_align(ndr, 4));
18428                 {
18429                         uint32_t _flags_save_string = ndr->flags;
18430                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18431                         NDR_CHECK(ndr_push_string(ndr, NDR_SCALARS, r->dll_name));
18432                         ndr->flags = _flags_save_string;
18433                 }
18434         }
18435         if (ndr_flags & NDR_BUFFERS) {
18436         }
18437         return NDR_ERR_SUCCESS;
18438 }
18439
18440 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_MonitorUi(struct ndr_pull *ndr, int ndr_flags, struct spoolss_MonitorUi *r)
18441 {
18442         if (ndr_flags & NDR_SCALARS) {
18443                 NDR_CHECK(ndr_pull_align(ndr, 4));
18444                 {
18445                         uint32_t _flags_save_string = ndr->flags;
18446                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
18447                         NDR_CHECK(ndr_pull_string(ndr, NDR_SCALARS, &r->dll_name));
18448                         ndr->flags = _flags_save_string;
18449                 }
18450         }
18451         if (ndr_flags & NDR_BUFFERS) {
18452         }
18453         return NDR_ERR_SUCCESS;
18454 }
18455
18456 _PUBLIC_ void ndr_print_spoolss_MonitorUi(struct ndr_print *ndr, const char *name, const struct spoolss_MonitorUi *r)
18457 {
18458         ndr_print_struct(ndr, name, "spoolss_MonitorUi");
18459         ndr->depth++;
18460         ndr_print_string(ndr, "dll_name", r->dll_name);
18461         ndr->depth--;
18462 }
18463
18464 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriverExFlags(struct ndr_push *ndr, int ndr_flags, uint32_t r)
18465 {
18466         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r));
18467         return NDR_ERR_SUCCESS;
18468 }
18469
18470 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverExFlags(struct ndr_pull *ndr, int ndr_flags, uint32_t *r)
18471 {
18472         uint32_t v;
18473         NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &v));
18474         *r = v;
18475         return NDR_ERR_SUCCESS;
18476 }
18477
18478 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverExFlags(struct ndr_print *ndr, const char *name, uint32_t r)
18479 {
18480         ndr_print_uint32(ndr, name, r);
18481         ndr->depth++;
18482         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_UPGRADE", APD_STRICT_UPGRADE, r);
18483         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_STRICT_DOWNGRADE", APD_STRICT_DOWNGRADE, r);
18484         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_ALL_FILES", APD_COPY_ALL_FILES, r);
18485         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_NEW_FILES", APD_COPY_NEW_FILES, r);
18486         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_FROM_DIRECTORY", APD_COPY_FROM_DIRECTORY, r);
18487         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_DONT_COPY_FILES_TO_CLUSTER", APD_DONT_COPY_FILES_TO_CLUSTER, r);
18488         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_COPY_TO_ALL_SPOOLERS", APD_COPY_TO_ALL_SPOOLERS, r);
18489         ndr_print_bitmap_flag(ndr, sizeof(uint32_t), "APD_RETURN_BLOCKING_STATUS_CODE", APD_RETURN_BLOCKING_STATUS_CODE, r);
18490         ndr->depth--;
18491 }
18492
18493 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinters *r)
18494 {
18495         if (flags & NDR_IN) {
18496                 NDR_CHECK(ndr_push_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, r->in.flags));
18497                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
18498                 if (r->in.server) {
18499                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18500                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18501                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
18502                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18503                 }
18504                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18505                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18506                 if (r->in.buffer) {
18507                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18508                 }
18509                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18510         }
18511         if (flags & NDR_OUT) {
18512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18513                 if (r->out.info) {
18514                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
18515                 }
18516                 if (r->out.needed == NULL) {
18517                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18518                 }
18519                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18520                 if (r->out.count == NULL) {
18521                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18522                 }
18523                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
18524                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18525         }
18526         return NDR_ERR_SUCCESS;
18527 }
18528
18529 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinters *r)
18530 {
18531         uint32_t _ptr_server;
18532         uint32_t _ptr_buffer;
18533         uint32_t _ptr_info;
18534         TALLOC_CTX *_mem_save_server_0;
18535         TALLOC_CTX *_mem_save_buffer_0;
18536         TALLOC_CTX *_mem_save_info_0;
18537         TALLOC_CTX *_mem_save_needed_0;
18538         TALLOC_CTX *_mem_save_count_0;
18539         if (flags & NDR_IN) {
18540                 ZERO_STRUCT(r->out);
18541
18542                 NDR_CHECK(ndr_pull_spoolss_EnumPrinterFlags(ndr, NDR_SCALARS, &r->in.flags));
18543                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
18544                 if (_ptr_server) {
18545                         NDR_PULL_ALLOC(ndr, r->in.server);
18546                 } else {
18547                         r->in.server = NULL;
18548                 }
18549                 if (r->in.server) {
18550                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
18551                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
18552                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
18553                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
18554                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
18555                                 return 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));
18556                         }
18557                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
18558                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
18559                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
18560                 }
18561                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18562                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18563                 if (_ptr_buffer) {
18564                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18565                 } else {
18566                         r->in.buffer = NULL;
18567                 }
18568                 if (r->in.buffer) {
18569                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
18570                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
18571                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
18572                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
18573                 }
18574                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
18575                 NDR_PULL_ALLOC(ndr, r->out.needed);
18576                 ZERO_STRUCTP(r->out.needed);
18577                 NDR_PULL_ALLOC(ndr, r->out.count);
18578                 ZERO_STRUCTP(r->out.count);
18579         }
18580         if (flags & NDR_OUT) {
18581                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
18582                 if (_ptr_info) {
18583                         NDR_PULL_ALLOC(ndr, r->out.info);
18584                 } else {
18585                         r->out.info = NULL;
18586                 }
18587                 if (r->out.info) {
18588                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18589                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18590                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
18591                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18592                 }
18593                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18594                         NDR_PULL_ALLOC(ndr, r->out.needed);
18595                 }
18596                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
18597                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
18598                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
18599                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
18600                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18601                         NDR_PULL_ALLOC(ndr, r->out.count);
18602                 }
18603                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
18604                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
18605                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
18606                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
18607                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18608         }
18609         return NDR_ERR_SUCCESS;
18610 }
18611
18612 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinters(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinters *r)
18613 {
18614         uint32_t cntr_info_0;
18615         if (flags & NDR_IN) {
18616                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
18618         }
18619         if (flags & NDR_OUT) {
18620                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18621                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18622                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18623                 }
18624                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18625                         NDR_CHECK(ndr_push_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18626                 }
18627         }
18628         return NDR_ERR_SUCCESS;
18629 }
18630
18631 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinters(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinters *r)
18632 {
18633         uint32_t cntr_info_0;
18634         TALLOC_CTX *_mem_save_info_0;
18635         if (flags & NDR_IN) {
18636                 ZERO_STRUCT(r->out);
18637
18638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18639                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
18640         }
18641         if (flags & NDR_OUT) {
18642                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
18643                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
18644                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
18645                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18646                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
18647                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
18648                 }
18649                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
18650                         NDR_CHECK(ndr_pull_spoolss_PrinterInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
18651                 }
18652                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
18653         }
18654         return NDR_ERR_SUCCESS;
18655 }
18656
18657 _PUBLIC_ void ndr_print_spoolss_EnumPrinters(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinters *r)
18658 {
18659         uint32_t cntr_info_2;
18660         ndr_print_struct(ndr, name, "spoolss_EnumPrinters");
18661         ndr->depth++;
18662         if (flags & NDR_SET_VALUES) {
18663                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18664         }
18665         if (flags & NDR_IN) {
18666                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinters");
18667                 ndr->depth++;
18668                 ndr_print_spoolss_EnumPrinterFlags(ndr, "flags", r->in.flags);
18669                 ndr_print_ptr(ndr, "server", r->in.server);
18670                 ndr->depth++;
18671                 if (r->in.server) {
18672                         ndr_print_string(ndr, "server", r->in.server);
18673                 }
18674                 ndr->depth--;
18675                 ndr_print_uint32(ndr, "level", r->in.level);
18676                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
18677                 ndr->depth++;
18678                 if (r->in.buffer) {
18679                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
18680                 }
18681                 ndr->depth--;
18682                 ndr_print_uint32(ndr, "offered", r->in.offered);
18683                 ndr->depth--;
18684         }
18685         if (flags & NDR_OUT) {
18686                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinters");
18687                 ndr->depth++;
18688                 ndr_print_ptr(ndr, "count", r->out.count);
18689                 ndr->depth++;
18690                 ndr_print_uint32(ndr, "count", *r->out.count);
18691                 ndr->depth--;
18692                 ndr_print_ptr(ndr, "info", r->out.info);
18693                 ndr->depth++;
18694                 ndr_print_ptr(ndr, "info", *r->out.info);
18695                 ndr->depth++;
18696                 if (*r->out.info) {
18697                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
18698                         ndr->depth++;
18699                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
18700                                 char *idx_2=NULL;
18701                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
18702                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
18703                                         ndr_print_spoolss_PrinterInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
18704                                         free(idx_2);
18705                                 }
18706                         }
18707                         ndr->depth--;
18708                 }
18709                 ndr->depth--;
18710                 ndr->depth--;
18711                 ndr_print_ptr(ndr, "needed", r->out.needed);
18712                 ndr->depth++;
18713                 ndr_print_uint32(ndr, "needed", *r->out.needed);
18714                 ndr->depth--;
18715                 ndr_print_WERROR(ndr, "result", r->out.result);
18716                 ndr->depth--;
18717         }
18718         ndr->depth--;
18719 }
18720
18721 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinter *r)
18722 {
18723         if (flags & NDR_IN) {
18724                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
18725                 if (r->in.printername) {
18726                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18727                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18728                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
18729                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18730                 }
18731                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
18732                 if (r->in.datatype) {
18733                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18734                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
18735                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
18736                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
18737                 }
18738                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18739                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
18740         }
18741         if (flags & NDR_OUT) {
18742                 if (r->out.handle == NULL) {
18743                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18744                 }
18745                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18746                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18747         }
18748         return NDR_ERR_SUCCESS;
18749 }
18750
18751 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinter *r)
18752 {
18753         uint32_t _ptr_printername;
18754         uint32_t _ptr_datatype;
18755         TALLOC_CTX *_mem_save_printername_0;
18756         TALLOC_CTX *_mem_save_datatype_0;
18757         TALLOC_CTX *_mem_save_handle_0;
18758         if (flags & NDR_IN) {
18759                 ZERO_STRUCT(r->out);
18760
18761                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
18762                 if (_ptr_printername) {
18763                         NDR_PULL_ALLOC(ndr, r->in.printername);
18764                 } else {
18765                         r->in.printername = NULL;
18766                 }
18767                 if (r->in.printername) {
18768                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
18769                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
18770                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
18771                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
18772                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
18773                                 return 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));
18774                         }
18775                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
18776                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
18777                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
18778                 }
18779                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
18780                 if (_ptr_datatype) {
18781                         NDR_PULL_ALLOC(ndr, r->in.datatype);
18782                 } else {
18783                         r->in.datatype = NULL;
18784                 }
18785                 if (r->in.datatype) {
18786                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
18787                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
18788                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
18789                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
18790                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
18791                                 return 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));
18792                         }
18793                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
18794                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
18795                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
18796                 }
18797                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
18798                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
18799                 NDR_PULL_ALLOC(ndr, r->out.handle);
18800                 ZERO_STRUCTP(r->out.handle);
18801         }
18802         if (flags & NDR_OUT) {
18803                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18804                         NDR_PULL_ALLOC(ndr, r->out.handle);
18805                 }
18806                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18807                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
18808                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
18809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18810                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18811         }
18812         return NDR_ERR_SUCCESS;
18813 }
18814
18815 _PUBLIC_ void ndr_print_spoolss_OpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinter *r)
18816 {
18817         ndr_print_struct(ndr, name, "spoolss_OpenPrinter");
18818         ndr->depth++;
18819         if (flags & NDR_SET_VALUES) {
18820                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18821         }
18822         if (flags & NDR_IN) {
18823                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinter");
18824                 ndr->depth++;
18825                 ndr_print_ptr(ndr, "printername", r->in.printername);
18826                 ndr->depth++;
18827                 if (r->in.printername) {
18828                         ndr_print_string(ndr, "printername", r->in.printername);
18829                 }
18830                 ndr->depth--;
18831                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
18832                 ndr->depth++;
18833                 if (r->in.datatype) {
18834                         ndr_print_string(ndr, "datatype", r->in.datatype);
18835                 }
18836                 ndr->depth--;
18837                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
18838                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
18839                 ndr->depth--;
18840         }
18841         if (flags & NDR_OUT) {
18842                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinter");
18843                 ndr->depth++;
18844                 ndr_print_ptr(ndr, "handle", r->out.handle);
18845                 ndr->depth++;
18846                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
18847                 ndr->depth--;
18848                 ndr_print_WERROR(ndr, "result", r->out.result);
18849                 ndr->depth--;
18850         }
18851         ndr->depth--;
18852 }
18853
18854 static enum ndr_err_code ndr_push_spoolss_SetJob(struct ndr_push *ndr, int flags, const struct spoolss_SetJob *r)
18855 {
18856         if (flags & NDR_IN) {
18857                 if (r->in.handle == NULL) {
18858                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18859                 }
18860                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18861                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18862                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.ctr));
18863                 if (r->in.ctr) {
18864                         NDR_CHECK(ndr_push_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18865                 }
18866                 NDR_CHECK(ndr_push_spoolss_JobControl(ndr, NDR_SCALARS, r->in.command));
18867         }
18868         if (flags & NDR_OUT) {
18869                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18870         }
18871         return NDR_ERR_SUCCESS;
18872 }
18873
18874 static enum ndr_err_code ndr_pull_spoolss_SetJob(struct ndr_pull *ndr, int flags, struct spoolss_SetJob *r)
18875 {
18876         uint32_t _ptr_ctr;
18877         TALLOC_CTX *_mem_save_handle_0;
18878         TALLOC_CTX *_mem_save_ctr_0;
18879         if (flags & NDR_IN) {
18880                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18881                         NDR_PULL_ALLOC(ndr, r->in.handle);
18882                 }
18883                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18884                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18885                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18886                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18887                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18888                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_ctr));
18889                 if (_ptr_ctr) {
18890                         NDR_PULL_ALLOC(ndr, r->in.ctr);
18891                 } else {
18892                         r->in.ctr = NULL;
18893                 }
18894                 if (r->in.ctr) {
18895                         _mem_save_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
18896                         NDR_PULL_SET_MEM_CTX(ndr, r->in.ctr, 0);
18897                         NDR_CHECK(ndr_pull_spoolss_JobInfoContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.ctr));
18898                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_ctr_0, 0);
18899                 }
18900                 NDR_CHECK(ndr_pull_spoolss_JobControl(ndr, NDR_SCALARS, &r->in.command));
18901         }
18902         if (flags & NDR_OUT) {
18903                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
18904         }
18905         return NDR_ERR_SUCCESS;
18906 }
18907
18908 _PUBLIC_ void ndr_print_spoolss_SetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetJob *r)
18909 {
18910         ndr_print_struct(ndr, name, "spoolss_SetJob");
18911         ndr->depth++;
18912         if (flags & NDR_SET_VALUES) {
18913                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
18914         }
18915         if (flags & NDR_IN) {
18916                 ndr_print_struct(ndr, "in", "spoolss_SetJob");
18917                 ndr->depth++;
18918                 ndr_print_ptr(ndr, "handle", r->in.handle);
18919                 ndr->depth++;
18920                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
18921                 ndr->depth--;
18922                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
18923                 ndr_print_ptr(ndr, "ctr", r->in.ctr);
18924                 ndr->depth++;
18925                 if (r->in.ctr) {
18926                         ndr_print_spoolss_JobInfoContainer(ndr, "ctr", r->in.ctr);
18927                 }
18928                 ndr->depth--;
18929                 ndr_print_spoolss_JobControl(ndr, "command", r->in.command);
18930                 ndr->depth--;
18931         }
18932         if (flags & NDR_OUT) {
18933                 ndr_print_struct(ndr, "out", "spoolss_SetJob");
18934                 ndr->depth++;
18935                 ndr_print_WERROR(ndr, "result", r->out.result);
18936                 ndr->depth--;
18937         }
18938         ndr->depth--;
18939 }
18940
18941 static enum ndr_err_code ndr_push_spoolss_GetJob(struct ndr_push *ndr, int flags, const struct spoolss_GetJob *r)
18942 {
18943         if (flags & NDR_IN) {
18944                 if (r->in.handle == NULL) {
18945                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18946                 }
18947                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18948                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.job_id));
18949                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
18950                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
18951                 if (r->in.buffer) {
18952                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
18953                 }
18954                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
18955         }
18956         if (flags & NDR_OUT) {
18957                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
18958                 if (r->out.info) {
18959                         {
18960                                 struct ndr_push *_ndr_info;
18961                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
18962                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
18963                                 NDR_CHECK(ndr_push_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
18964                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
18965                         }
18966                 }
18967                 if (r->out.needed == NULL) {
18968                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
18969                 }
18970                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
18971                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
18972         }
18973         return NDR_ERR_SUCCESS;
18974 }
18975
18976 static enum ndr_err_code ndr_pull_spoolss_GetJob(struct ndr_pull *ndr, int flags, struct spoolss_GetJob *r)
18977 {
18978         uint32_t _ptr_buffer;
18979         uint32_t _ptr_info;
18980         TALLOC_CTX *_mem_save_handle_0;
18981         TALLOC_CTX *_mem_save_buffer_0;
18982         TALLOC_CTX *_mem_save_info_0;
18983         TALLOC_CTX *_mem_save_needed_0;
18984         if (flags & NDR_IN) {
18985                 ZERO_STRUCT(r->out);
18986
18987                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
18988                         NDR_PULL_ALLOC(ndr, r->in.handle);
18989                 }
18990                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
18991                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
18992                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
18993                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
18994                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.job_id));
18995                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
18996                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
18997                 if (_ptr_buffer) {
18998                         NDR_PULL_ALLOC(ndr, r->in.buffer);
18999                 } else {
19000                         r->in.buffer = NULL;
19001                 }
19002                 if (r->in.buffer) {
19003                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19004                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19005                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19006                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19007                 }
19008                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19009                 NDR_PULL_ALLOC(ndr, r->out.needed);
19010                 ZERO_STRUCTP(r->out.needed);
19011         }
19012         if (flags & NDR_OUT) {
19013                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19014                 if (_ptr_info) {
19015                         NDR_PULL_ALLOC(ndr, r->out.info);
19016                 } else {
19017                         r->out.info = NULL;
19018                 }
19019                 if (r->out.info) {
19020                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19021                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19022                         {
19023                                 struct ndr_pull *_ndr_info;
19024                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19025                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19026                                 NDR_CHECK(ndr_pull_spoolss_JobInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19027                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19028                         }
19029                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19030                 }
19031                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19032                         NDR_PULL_ALLOC(ndr, r->out.needed);
19033                 }
19034                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19035                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19036                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19037                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19038                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19039         }
19040         return NDR_ERR_SUCCESS;
19041 }
19042
19043 _PUBLIC_ void ndr_print_spoolss_GetJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetJob *r)
19044 {
19045         ndr_print_struct(ndr, name, "spoolss_GetJob");
19046         ndr->depth++;
19047         if (flags & NDR_SET_VALUES) {
19048                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19049         }
19050         if (flags & NDR_IN) {
19051                 ndr_print_struct(ndr, "in", "spoolss_GetJob");
19052                 ndr->depth++;
19053                 ndr_print_ptr(ndr, "handle", r->in.handle);
19054                 ndr->depth++;
19055                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19056                 ndr->depth--;
19057                 ndr_print_uint32(ndr, "job_id", r->in.job_id);
19058                 ndr_print_uint32(ndr, "level", r->in.level);
19059                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19060                 ndr->depth++;
19061                 if (r->in.buffer) {
19062                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19063                 }
19064                 ndr->depth--;
19065                 ndr_print_uint32(ndr, "offered", r->in.offered);
19066                 ndr->depth--;
19067         }
19068         if (flags & NDR_OUT) {
19069                 ndr_print_struct(ndr, "out", "spoolss_GetJob");
19070                 ndr->depth++;
19071                 ndr_print_ptr(ndr, "info", r->out.info);
19072                 ndr->depth++;
19073                 if (r->out.info) {
19074                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19075                         ndr_print_spoolss_JobInfo(ndr, "info", r->out.info);
19076                 }
19077                 ndr->depth--;
19078                 ndr_print_ptr(ndr, "needed", r->out.needed);
19079                 ndr->depth++;
19080                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19081                 ndr->depth--;
19082                 ndr_print_WERROR(ndr, "result", r->out.result);
19083                 ndr->depth--;
19084         }
19085         ndr->depth--;
19086 }
19087
19088 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct _spoolss_EnumJobs *r)
19089 {
19090         if (flags & NDR_IN) {
19091                 if (r->in.handle == NULL) {
19092                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19093                 }
19094                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19095                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.firstjob));
19096                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.numjobs));
19097                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19098                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19099                 if (r->in.buffer) {
19100                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19101                 }
19102                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19103         }
19104         if (flags & NDR_OUT) {
19105                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19106                 if (r->out.info) {
19107                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19108                 }
19109                 if (r->out.needed == NULL) {
19110                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19111                 }
19112                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19113                 if (r->out.count == NULL) {
19114                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19115                 }
19116                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19117                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19118         }
19119         return NDR_ERR_SUCCESS;
19120 }
19121
19122 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct _spoolss_EnumJobs *r)
19123 {
19124         uint32_t _ptr_buffer;
19125         uint32_t _ptr_info;
19126         TALLOC_CTX *_mem_save_handle_0;
19127         TALLOC_CTX *_mem_save_buffer_0;
19128         TALLOC_CTX *_mem_save_info_0;
19129         TALLOC_CTX *_mem_save_needed_0;
19130         TALLOC_CTX *_mem_save_count_0;
19131         if (flags & NDR_IN) {
19132                 ZERO_STRUCT(r->out);
19133
19134                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19135                         NDR_PULL_ALLOC(ndr, r->in.handle);
19136                 }
19137                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19138                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19139                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19140                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.firstjob));
19142                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.numjobs));
19143                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19144                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19145                 if (_ptr_buffer) {
19146                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19147                 } else {
19148                         r->in.buffer = NULL;
19149                 }
19150                 if (r->in.buffer) {
19151                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19152                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19153                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19154                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19155                 }
19156                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19157                 NDR_PULL_ALLOC(ndr, r->out.needed);
19158                 ZERO_STRUCTP(r->out.needed);
19159                 NDR_PULL_ALLOC(ndr, r->out.count);
19160                 ZERO_STRUCTP(r->out.count);
19161         }
19162         if (flags & NDR_OUT) {
19163                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19164                 if (_ptr_info) {
19165                         NDR_PULL_ALLOC(ndr, r->out.info);
19166                 } else {
19167                         r->out.info = NULL;
19168                 }
19169                 if (r->out.info) {
19170                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19171                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19172                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19173                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19174                 }
19175                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19176                         NDR_PULL_ALLOC(ndr, r->out.needed);
19177                 }
19178                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19179                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19180                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19181                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19182                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19183                         NDR_PULL_ALLOC(ndr, r->out.count);
19184                 }
19185                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19186                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19188                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19189                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19190         }
19191         return NDR_ERR_SUCCESS;
19192 }
19193
19194 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumJobs(struct ndr_push *ndr, int flags, const struct __spoolss_EnumJobs *r)
19195 {
19196         uint32_t cntr_info_0;
19197         if (flags & NDR_IN) {
19198                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19199                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19200         }
19201         if (flags & NDR_OUT) {
19202                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19203                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19204                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19205                 }
19206                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19207                         NDR_CHECK(ndr_push_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19208                 }
19209         }
19210         return NDR_ERR_SUCCESS;
19211 }
19212
19213 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumJobs(struct ndr_pull *ndr, int flags, struct __spoolss_EnumJobs *r)
19214 {
19215         uint32_t cntr_info_0;
19216         TALLOC_CTX *_mem_save_info_0;
19217         if (flags & NDR_IN) {
19218                 ZERO_STRUCT(r->out);
19219
19220                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19221                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19222         }
19223         if (flags & NDR_OUT) {
19224                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19225                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19226                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19227                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19228                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19229                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19230                 }
19231                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19232                         NDR_CHECK(ndr_pull_spoolss_JobInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19233                 }
19234                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19235         }
19236         return NDR_ERR_SUCCESS;
19237 }
19238
19239 _PUBLIC_ void ndr_print_spoolss_EnumJobs(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumJobs *r)
19240 {
19241         uint32_t cntr_info_2;
19242         ndr_print_struct(ndr, name, "spoolss_EnumJobs");
19243         ndr->depth++;
19244         if (flags & NDR_SET_VALUES) {
19245                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19246         }
19247         if (flags & NDR_IN) {
19248                 ndr_print_struct(ndr, "in", "spoolss_EnumJobs");
19249                 ndr->depth++;
19250                 ndr_print_ptr(ndr, "handle", r->in.handle);
19251                 ndr->depth++;
19252                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19253                 ndr->depth--;
19254                 ndr_print_uint32(ndr, "firstjob", r->in.firstjob);
19255                 ndr_print_uint32(ndr, "numjobs", r->in.numjobs);
19256                 ndr_print_uint32(ndr, "level", r->in.level);
19257                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19258                 ndr->depth++;
19259                 if (r->in.buffer) {
19260                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19261                 }
19262                 ndr->depth--;
19263                 ndr_print_uint32(ndr, "offered", r->in.offered);
19264                 ndr->depth--;
19265         }
19266         if (flags & NDR_OUT) {
19267                 ndr_print_struct(ndr, "out", "spoolss_EnumJobs");
19268                 ndr->depth++;
19269                 ndr_print_ptr(ndr, "count", r->out.count);
19270                 ndr->depth++;
19271                 ndr_print_uint32(ndr, "count", *r->out.count);
19272                 ndr->depth--;
19273                 ndr_print_ptr(ndr, "info", r->out.info);
19274                 ndr->depth++;
19275                 ndr_print_ptr(ndr, "info", *r->out.info);
19276                 ndr->depth++;
19277                 if (*r->out.info) {
19278                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19279                         ndr->depth++;
19280                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19281                                 char *idx_2=NULL;
19282                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19283                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19284                                         ndr_print_spoolss_JobInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19285                                         free(idx_2);
19286                                 }
19287                         }
19288                         ndr->depth--;
19289                 }
19290                 ndr->depth--;
19291                 ndr->depth--;
19292                 ndr_print_ptr(ndr, "needed", r->out.needed);
19293                 ndr->depth++;
19294                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19295                 ndr->depth--;
19296                 ndr_print_WERROR(ndr, "result", r->out.result);
19297                 ndr->depth--;
19298         }
19299         ndr->depth--;
19300 }
19301
19302 static enum ndr_err_code ndr_push_spoolss_AddPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinter *r)
19303 {
19304         if (flags & NDR_IN) {
19305         }
19306         if (flags & NDR_OUT) {
19307                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19308         }
19309         return NDR_ERR_SUCCESS;
19310 }
19311
19312 static enum ndr_err_code ndr_pull_spoolss_AddPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinter *r)
19313 {
19314         if (flags & NDR_IN) {
19315         }
19316         if (flags & NDR_OUT) {
19317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19318         }
19319         return NDR_ERR_SUCCESS;
19320 }
19321
19322 _PUBLIC_ void ndr_print_spoolss_AddPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinter *r)
19323 {
19324         ndr_print_struct(ndr, name, "spoolss_AddPrinter");
19325         ndr->depth++;
19326         if (flags & NDR_SET_VALUES) {
19327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19328         }
19329         if (flags & NDR_IN) {
19330                 ndr_print_struct(ndr, "in", "spoolss_AddPrinter");
19331                 ndr->depth++;
19332                 ndr->depth--;
19333         }
19334         if (flags & NDR_OUT) {
19335                 ndr_print_struct(ndr, "out", "spoolss_AddPrinter");
19336                 ndr->depth++;
19337                 ndr_print_WERROR(ndr, "result", r->out.result);
19338                 ndr->depth--;
19339         }
19340         ndr->depth--;
19341 }
19342
19343 static enum ndr_err_code ndr_push_spoolss_DeletePrinter(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinter *r)
19344 {
19345         if (flags & NDR_IN) {
19346                 if (r->in.handle == NULL) {
19347                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19348                 }
19349                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19350         }
19351         if (flags & NDR_OUT) {
19352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19353         }
19354         return NDR_ERR_SUCCESS;
19355 }
19356
19357 static enum ndr_err_code ndr_pull_spoolss_DeletePrinter(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinter *r)
19358 {
19359         TALLOC_CTX *_mem_save_handle_0;
19360         if (flags & NDR_IN) {
19361                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19362                         NDR_PULL_ALLOC(ndr, r->in.handle);
19363                 }
19364                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19365                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19366                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19367                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19368         }
19369         if (flags & NDR_OUT) {
19370                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19371         }
19372         return NDR_ERR_SUCCESS;
19373 }
19374
19375 _PUBLIC_ void ndr_print_spoolss_DeletePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinter *r)
19376 {
19377         ndr_print_struct(ndr, name, "spoolss_DeletePrinter");
19378         ndr->depth++;
19379         if (flags & NDR_SET_VALUES) {
19380                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19381         }
19382         if (flags & NDR_IN) {
19383                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinter");
19384                 ndr->depth++;
19385                 ndr_print_ptr(ndr, "handle", r->in.handle);
19386                 ndr->depth++;
19387                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19388                 ndr->depth--;
19389                 ndr->depth--;
19390         }
19391         if (flags & NDR_OUT) {
19392                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinter");
19393                 ndr->depth++;
19394                 ndr_print_WERROR(ndr, "result", r->out.result);
19395                 ndr->depth--;
19396         }
19397         ndr->depth--;
19398 }
19399
19400 static enum ndr_err_code ndr_push_spoolss_SetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinter *r)
19401 {
19402         if (flags & NDR_IN) {
19403                 if (r->in.handle == NULL) {
19404                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19405                 }
19406                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19407                 if (r->in.info_ctr == NULL) {
19408                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19409                 }
19410                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19411                 if (r->in.devmode_ctr == NULL) {
19412                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19413                 }
19414                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19415                 if (r->in.secdesc_ctr == NULL) {
19416                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19417                 }
19418                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19419                 NDR_CHECK(ndr_push_spoolss_PrinterControl(ndr, NDR_SCALARS, r->in.command));
19420         }
19421         if (flags & NDR_OUT) {
19422                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19423         }
19424         return NDR_ERR_SUCCESS;
19425 }
19426
19427 static enum ndr_err_code ndr_pull_spoolss_SetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinter *r)
19428 {
19429         TALLOC_CTX *_mem_save_handle_0;
19430         TALLOC_CTX *_mem_save_info_ctr_0;
19431         TALLOC_CTX *_mem_save_devmode_ctr_0;
19432         TALLOC_CTX *_mem_save_secdesc_ctr_0;
19433         if (flags & NDR_IN) {
19434                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19435                         NDR_PULL_ALLOC(ndr, r->in.handle);
19436                 }
19437                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19438                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19439                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19440                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19441                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19442                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19443                 }
19444                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19445                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19446                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19447                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19448                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19449                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
19450                 }
19451                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19452                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
19453                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
19454                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19455                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19456                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
19457                 }
19458                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19459                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
19460                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
19461                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19462                 NDR_CHECK(ndr_pull_spoolss_PrinterControl(ndr, NDR_SCALARS, &r->in.command));
19463         }
19464         if (flags & NDR_OUT) {
19465                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19466         }
19467         return NDR_ERR_SUCCESS;
19468 }
19469
19470 _PUBLIC_ void ndr_print_spoolss_SetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinter *r)
19471 {
19472         ndr_print_struct(ndr, name, "spoolss_SetPrinter");
19473         ndr->depth++;
19474         if (flags & NDR_SET_VALUES) {
19475                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19476         }
19477         if (flags & NDR_IN) {
19478                 ndr_print_struct(ndr, "in", "spoolss_SetPrinter");
19479                 ndr->depth++;
19480                 ndr_print_ptr(ndr, "handle", r->in.handle);
19481                 ndr->depth++;
19482                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19483                 ndr->depth--;
19484                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19485                 ndr->depth++;
19486                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19487                 ndr->depth--;
19488                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
19489                 ndr->depth++;
19490                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
19491                 ndr->depth--;
19492                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19493                 ndr->depth++;
19494                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
19495                 ndr->depth--;
19496                 ndr_print_spoolss_PrinterControl(ndr, "command", r->in.command);
19497                 ndr->depth--;
19498         }
19499         if (flags & NDR_OUT) {
19500                 ndr_print_struct(ndr, "out", "spoolss_SetPrinter");
19501                 ndr->depth++;
19502                 ndr_print_WERROR(ndr, "result", r->out.result);
19503                 ndr->depth--;
19504         }
19505         ndr->depth--;
19506 }
19507
19508 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinter *r)
19509 {
19510         if (flags & NDR_IN) {
19511                 if (r->in.handle == NULL) {
19512                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19513                 }
19514                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19515                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19516                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19517                 if (r->in.buffer) {
19518                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19519                 }
19520                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19521         }
19522         if (flags & NDR_OUT) {
19523                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19524                 if (r->out.info) {
19525                         {
19526                                 struct ndr_push *_ndr_info;
19527                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19528                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
19529                                 NDR_CHECK(ndr_push_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19530                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19531                         }
19532                 }
19533                 if (r->out.needed == NULL) {
19534                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19535                 }
19536                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19537                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19538         }
19539         return NDR_ERR_SUCCESS;
19540 }
19541
19542 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinter *r)
19543 {
19544         uint32_t _ptr_buffer;
19545         uint32_t _ptr_info;
19546         TALLOC_CTX *_mem_save_handle_0;
19547         TALLOC_CTX *_mem_save_buffer_0;
19548         TALLOC_CTX *_mem_save_info_0;
19549         TALLOC_CTX *_mem_save_needed_0;
19550         if (flags & NDR_IN) {
19551                 ZERO_STRUCT(r->out);
19552
19553                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19554                         NDR_PULL_ALLOC(ndr, r->in.handle);
19555                 }
19556                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
19557                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
19558                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
19559                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
19560                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19561                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19562                 if (_ptr_buffer) {
19563                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19564                 } else {
19565                         r->in.buffer = NULL;
19566                 }
19567                 if (r->in.buffer) {
19568                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19569                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19570                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19571                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19572                 }
19573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19574                 NDR_PULL_ALLOC(ndr, r->out.needed);
19575                 ZERO_STRUCTP(r->out.needed);
19576         }
19577         if (flags & NDR_OUT) {
19578                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19579                 if (_ptr_info) {
19580                         NDR_PULL_ALLOC(ndr, r->out.info);
19581                 } else {
19582                         r->out.info = NULL;
19583                 }
19584                 if (r->out.info) {
19585                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19586                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19587                         {
19588                                 struct ndr_pull *_ndr_info;
19589                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
19590                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
19591                                 NDR_CHECK(ndr_pull_spoolss_PrinterInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
19592                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
19593                         }
19594                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19595                 }
19596                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19597                         NDR_PULL_ALLOC(ndr, r->out.needed);
19598                 }
19599                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19600                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19601                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19602                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19603                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19604         }
19605         return NDR_ERR_SUCCESS;
19606 }
19607
19608 _PUBLIC_ void ndr_print_spoolss_GetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinter *r)
19609 {
19610         ndr_print_struct(ndr, name, "spoolss_GetPrinter");
19611         ndr->depth++;
19612         if (flags & NDR_SET_VALUES) {
19613                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19614         }
19615         if (flags & NDR_IN) {
19616                 ndr_print_struct(ndr, "in", "spoolss_GetPrinter");
19617                 ndr->depth++;
19618                 ndr_print_ptr(ndr, "handle", r->in.handle);
19619                 ndr->depth++;
19620                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
19621                 ndr->depth--;
19622                 ndr_print_uint32(ndr, "level", r->in.level);
19623                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19624                 ndr->depth++;
19625                 if (r->in.buffer) {
19626                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19627                 }
19628                 ndr->depth--;
19629                 ndr_print_uint32(ndr, "offered", r->in.offered);
19630                 ndr->depth--;
19631         }
19632         if (flags & NDR_OUT) {
19633                 ndr_print_struct(ndr, "out", "spoolss_GetPrinter");
19634                 ndr->depth++;
19635                 ndr_print_ptr(ndr, "info", r->out.info);
19636                 ndr->depth++;
19637                 if (r->out.info) {
19638                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
19639                         ndr_print_spoolss_PrinterInfo(ndr, "info", r->out.info);
19640                 }
19641                 ndr->depth--;
19642                 ndr_print_ptr(ndr, "needed", r->out.needed);
19643                 ndr->depth++;
19644                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19645                 ndr->depth--;
19646                 ndr_print_WERROR(ndr, "result", r->out.result);
19647                 ndr->depth--;
19648         }
19649         ndr->depth--;
19650 }
19651
19652 static enum ndr_err_code ndr_push_spoolss_AddPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriver *r)
19653 {
19654         if (flags & NDR_IN) {
19655                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
19656                 if (r->in.servername) {
19657                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19658                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19659                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
19660                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19661                 }
19662                 if (r->in.info_ctr == NULL) {
19663                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19664                 }
19665                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19666         }
19667         if (flags & NDR_OUT) {
19668                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19669         }
19670         return NDR_ERR_SUCCESS;
19671 }
19672
19673 static enum ndr_err_code ndr_pull_spoolss_AddPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriver *r)
19674 {
19675         uint32_t _ptr_servername;
19676         TALLOC_CTX *_mem_save_servername_0;
19677         TALLOC_CTX *_mem_save_info_ctr_0;
19678         if (flags & NDR_IN) {
19679                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
19680                 if (_ptr_servername) {
19681                         NDR_PULL_ALLOC(ndr, r->in.servername);
19682                 } else {
19683                         r->in.servername = NULL;
19684                 }
19685                 if (r->in.servername) {
19686                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
19687                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
19688                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
19689                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
19690                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
19691                                 return 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));
19692                         }
19693                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
19694                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
19695                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
19696                 }
19697                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19698                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
19699                 }
19700                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
19701                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
19702                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
19703                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
19704         }
19705         if (flags & NDR_OUT) {
19706                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19707         }
19708         return NDR_ERR_SUCCESS;
19709 }
19710
19711 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriver *r)
19712 {
19713         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriver");
19714         ndr->depth++;
19715         if (flags & NDR_SET_VALUES) {
19716                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19717         }
19718         if (flags & NDR_IN) {
19719                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriver");
19720                 ndr->depth++;
19721                 ndr_print_ptr(ndr, "servername", r->in.servername);
19722                 ndr->depth++;
19723                 if (r->in.servername) {
19724                         ndr_print_string(ndr, "servername", r->in.servername);
19725                 }
19726                 ndr->depth--;
19727                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
19728                 ndr->depth++;
19729                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
19730                 ndr->depth--;
19731                 ndr->depth--;
19732         }
19733         if (flags & NDR_OUT) {
19734                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriver");
19735                 ndr->depth++;
19736                 ndr_print_WERROR(ndr, "result", r->out.result);
19737                 ndr->depth--;
19738         }
19739         ndr->depth--;
19740 }
19741
19742 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrinterDrivers *r)
19743 {
19744         if (flags & NDR_IN) {
19745                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
19746                 if (r->in.server) {
19747                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19748                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19749                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
19750                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19751                 }
19752                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
19753                 if (r->in.environment) {
19754                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19755                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
19756                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
19757                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
19758                 }
19759                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19760                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
19761                 if (r->in.buffer) {
19762                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
19763                 }
19764                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
19765         }
19766         if (flags & NDR_OUT) {
19767                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
19768                 if (r->out.info) {
19769                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
19770                 }
19771                 if (r->out.needed == NULL) {
19772                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19773                 }
19774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
19775                 if (r->out.count == NULL) {
19776                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
19777                 }
19778                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
19779                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
19780         }
19781         return NDR_ERR_SUCCESS;
19782 }
19783
19784 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrinterDrivers *r)
19785 {
19786         uint32_t _ptr_server;
19787         uint32_t _ptr_environment;
19788         uint32_t _ptr_buffer;
19789         uint32_t _ptr_info;
19790         TALLOC_CTX *_mem_save_server_0;
19791         TALLOC_CTX *_mem_save_environment_0;
19792         TALLOC_CTX *_mem_save_buffer_0;
19793         TALLOC_CTX *_mem_save_info_0;
19794         TALLOC_CTX *_mem_save_needed_0;
19795         TALLOC_CTX *_mem_save_count_0;
19796         if (flags & NDR_IN) {
19797                 ZERO_STRUCT(r->out);
19798
19799                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
19800                 if (_ptr_server) {
19801                         NDR_PULL_ALLOC(ndr, r->in.server);
19802                 } else {
19803                         r->in.server = NULL;
19804                 }
19805                 if (r->in.server) {
19806                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
19807                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
19808                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
19809                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
19810                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
19811                                 return 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));
19812                         }
19813                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
19814                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
19815                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
19816                 }
19817                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
19818                 if (_ptr_environment) {
19819                         NDR_PULL_ALLOC(ndr, r->in.environment);
19820                 } else {
19821                         r->in.environment = NULL;
19822                 }
19823                 if (r->in.environment) {
19824                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
19825                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
19826                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
19827                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
19828                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
19829                                 return 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));
19830                         }
19831                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
19832                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
19833                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
19834                 }
19835                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19836                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
19837                 if (_ptr_buffer) {
19838                         NDR_PULL_ALLOC(ndr, r->in.buffer);
19839                 } else {
19840                         r->in.buffer = NULL;
19841                 }
19842                 if (r->in.buffer) {
19843                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
19844                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
19845                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
19846                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
19847                 }
19848                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
19849                 NDR_PULL_ALLOC(ndr, r->out.needed);
19850                 ZERO_STRUCTP(r->out.needed);
19851                 NDR_PULL_ALLOC(ndr, r->out.count);
19852                 ZERO_STRUCTP(r->out.count);
19853         }
19854         if (flags & NDR_OUT) {
19855                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
19856                 if (_ptr_info) {
19857                         NDR_PULL_ALLOC(ndr, r->out.info);
19858                 } else {
19859                         r->out.info = NULL;
19860                 }
19861                 if (r->out.info) {
19862                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19863                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19864                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
19865                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19866                 }
19867                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19868                         NDR_PULL_ALLOC(ndr, r->out.needed);
19869                 }
19870                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
19871                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
19872                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
19873                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
19874                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
19875                         NDR_PULL_ALLOC(ndr, r->out.count);
19876                 }
19877                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
19878                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
19879                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
19880                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
19881                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
19882         }
19883         return NDR_ERR_SUCCESS;
19884 }
19885
19886 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrinterDrivers(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrinterDrivers *r)
19887 {
19888         uint32_t cntr_info_0;
19889         if (flags & NDR_IN) {
19890                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
19891                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
19892         }
19893         if (flags & NDR_OUT) {
19894                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19895                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19896                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19897                 }
19898                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19899                         NDR_CHECK(ndr_push_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19900                 }
19901         }
19902         return NDR_ERR_SUCCESS;
19903 }
19904
19905 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrinterDrivers(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrinterDrivers *r)
19906 {
19907         uint32_t cntr_info_0;
19908         TALLOC_CTX *_mem_save_info_0;
19909         if (flags & NDR_IN) {
19910                 ZERO_STRUCT(r->out);
19911
19912                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
19913                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
19914         }
19915         if (flags & NDR_OUT) {
19916                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
19917                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
19918                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
19919                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19920                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
19921                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
19922                 }
19923                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
19924                         NDR_CHECK(ndr_pull_spoolss_DriverInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
19925                 }
19926                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
19927         }
19928         return NDR_ERR_SUCCESS;
19929 }
19930
19931 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDrivers(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDrivers *r)
19932 {
19933         uint32_t cntr_info_2;
19934         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDrivers");
19935         ndr->depth++;
19936         if (flags & NDR_SET_VALUES) {
19937                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
19938         }
19939         if (flags & NDR_IN) {
19940                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDrivers");
19941                 ndr->depth++;
19942                 ndr_print_ptr(ndr, "server", r->in.server);
19943                 ndr->depth++;
19944                 if (r->in.server) {
19945                         ndr_print_string(ndr, "server", r->in.server);
19946                 }
19947                 ndr->depth--;
19948                 ndr_print_ptr(ndr, "environment", r->in.environment);
19949                 ndr->depth++;
19950                 if (r->in.environment) {
19951                         ndr_print_string(ndr, "environment", r->in.environment);
19952                 }
19953                 ndr->depth--;
19954                 ndr_print_uint32(ndr, "level", r->in.level);
19955                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
19956                 ndr->depth++;
19957                 if (r->in.buffer) {
19958                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
19959                 }
19960                 ndr->depth--;
19961                 ndr_print_uint32(ndr, "offered", r->in.offered);
19962                 ndr->depth--;
19963         }
19964         if (flags & NDR_OUT) {
19965                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDrivers");
19966                 ndr->depth++;
19967                 ndr_print_ptr(ndr, "count", r->out.count);
19968                 ndr->depth++;
19969                 ndr_print_uint32(ndr, "count", *r->out.count);
19970                 ndr->depth--;
19971                 ndr_print_ptr(ndr, "info", r->out.info);
19972                 ndr->depth++;
19973                 ndr_print_ptr(ndr, "info", *r->out.info);
19974                 ndr->depth++;
19975                 if (*r->out.info) {
19976                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
19977                         ndr->depth++;
19978                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
19979                                 char *idx_2=NULL;
19980                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
19981                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
19982                                         ndr_print_spoolss_DriverInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
19983                                         free(idx_2);
19984                                 }
19985                         }
19986                         ndr->depth--;
19987                 }
19988                 ndr->depth--;
19989                 ndr->depth--;
19990                 ndr_print_ptr(ndr, "needed", r->out.needed);
19991                 ndr->depth++;
19992                 ndr_print_uint32(ndr, "needed", *r->out.needed);
19993                 ndr->depth--;
19994                 ndr_print_WERROR(ndr, "result", r->out.result);
19995                 ndr->depth--;
19996         }
19997         ndr->depth--;
19998 }
19999
20000 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver *r)
20001 {
20002         if (flags & NDR_IN) {
20003         }
20004         if (flags & NDR_OUT) {
20005                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20006         }
20007         return NDR_ERR_SUCCESS;
20008 }
20009
20010 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver *r)
20011 {
20012         if (flags & NDR_IN) {
20013         }
20014         if (flags & NDR_OUT) {
20015                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20016         }
20017         return NDR_ERR_SUCCESS;
20018 }
20019
20020 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver *r)
20021 {
20022         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver");
20023         ndr->depth++;
20024         if (flags & NDR_SET_VALUES) {
20025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20026         }
20027         if (flags & NDR_IN) {
20028                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver");
20029                 ndr->depth++;
20030                 ndr->depth--;
20031         }
20032         if (flags & NDR_OUT) {
20033                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver");
20034                 ndr->depth++;
20035                 ndr_print_WERROR(ndr, "result", r->out.result);
20036                 ndr->depth--;
20037         }
20038         ndr->depth--;
20039 }
20040
20041 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_GetPrinterDriverDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20042 {
20043         if (flags & NDR_IN) {
20044                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20045                 if (r->in.server) {
20046                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20047                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20048                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20049                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20050                 }
20051                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20052                 if (r->in.environment) {
20053                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20054                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20055                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20056                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20057                 }
20058                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20059                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20060                 if (r->in.buffer) {
20061                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20062                 }
20063                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20064         }
20065         if (flags & NDR_OUT) {
20066                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20067                 if (r->out.info) {
20068                         {
20069                                 struct ndr_push *_ndr_info;
20070                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20071                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20072                                 NDR_CHECK(ndr_push_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20073                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20074                         }
20075                 }
20076                 if (r->out.needed == NULL) {
20077                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20078                 }
20079                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20080                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20081         }
20082         return NDR_ERR_SUCCESS;
20083 }
20084
20085 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_GetPrinterDriverDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriverDirectory *r)
20086 {
20087         uint32_t _ptr_server;
20088         uint32_t _ptr_environment;
20089         uint32_t _ptr_buffer;
20090         uint32_t _ptr_info;
20091         TALLOC_CTX *_mem_save_server_0;
20092         TALLOC_CTX *_mem_save_environment_0;
20093         TALLOC_CTX *_mem_save_buffer_0;
20094         TALLOC_CTX *_mem_save_info_0;
20095         TALLOC_CTX *_mem_save_needed_0;
20096         if (flags & NDR_IN) {
20097                 ZERO_STRUCT(r->out);
20098
20099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20100                 if (_ptr_server) {
20101                         NDR_PULL_ALLOC(ndr, r->in.server);
20102                 } else {
20103                         r->in.server = NULL;
20104                 }
20105                 if (r->in.server) {
20106                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20107                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20108                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20109                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20110                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20111                                 return 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));
20112                         }
20113                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20114                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20115                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20116                 }
20117                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20118                 if (_ptr_environment) {
20119                         NDR_PULL_ALLOC(ndr, r->in.environment);
20120                 } else {
20121                         r->in.environment = NULL;
20122                 }
20123                 if (r->in.environment) {
20124                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20125                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20126                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20127                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20128                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20129                                 return 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));
20130                         }
20131                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20132                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20133                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20134                 }
20135                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20136                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20137                 if (_ptr_buffer) {
20138                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20139                 } else {
20140                         r->in.buffer = NULL;
20141                 }
20142                 if (r->in.buffer) {
20143                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20144                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20145                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20146                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20147                 }
20148                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20149                 NDR_PULL_ALLOC(ndr, r->out.needed);
20150                 ZERO_STRUCTP(r->out.needed);
20151         }
20152         if (flags & NDR_OUT) {
20153                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20154                 if (_ptr_info) {
20155                         NDR_PULL_ALLOC(ndr, r->out.info);
20156                 } else {
20157                         r->out.info = NULL;
20158                 }
20159                 if (r->out.info) {
20160                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20161                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20162                         {
20163                                 struct ndr_pull *_ndr_info;
20164                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20165                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20166                                 NDR_CHECK(ndr_pull_spoolss_DriverDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20167                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20168                         }
20169                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20170                 }
20171                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20172                         NDR_PULL_ALLOC(ndr, r->out.needed);
20173                 }
20174                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20175                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20176                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20177                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20178                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20179         }
20180         return NDR_ERR_SUCCESS;
20181 }
20182
20183 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriverDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriverDirectory *r)
20184 {
20185         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriverDirectory");
20186         ndr->depth++;
20187         if (flags & NDR_SET_VALUES) {
20188                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20189         }
20190         if (flags & NDR_IN) {
20191                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriverDirectory");
20192                 ndr->depth++;
20193                 ndr_print_ptr(ndr, "server", r->in.server);
20194                 ndr->depth++;
20195                 if (r->in.server) {
20196                         ndr_print_string(ndr, "server", r->in.server);
20197                 }
20198                 ndr->depth--;
20199                 ndr_print_ptr(ndr, "environment", r->in.environment);
20200                 ndr->depth++;
20201                 if (r->in.environment) {
20202                         ndr_print_string(ndr, "environment", r->in.environment);
20203                 }
20204                 ndr->depth--;
20205                 ndr_print_uint32(ndr, "level", r->in.level);
20206                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20207                 ndr->depth++;
20208                 if (r->in.buffer) {
20209                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20210                 }
20211                 ndr->depth--;
20212                 ndr_print_uint32(ndr, "offered", r->in.offered);
20213                 ndr->depth--;
20214         }
20215         if (flags & NDR_OUT) {
20216                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriverDirectory");
20217                 ndr->depth++;
20218                 ndr_print_ptr(ndr, "info", r->out.info);
20219                 ndr->depth++;
20220                 if (r->out.info) {
20221                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20222                         ndr_print_spoolss_DriverDirectoryInfo(ndr, "info", r->out.info);
20223                 }
20224                 ndr->depth--;
20225                 ndr_print_ptr(ndr, "needed", r->out.needed);
20226                 ndr->depth++;
20227                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20228                 ndr->depth--;
20229                 ndr_print_WERROR(ndr, "result", r->out.result);
20230                 ndr->depth--;
20231         }
20232         ndr->depth--;
20233 }
20234
20235 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriver(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriver *r)
20236 {
20237         if (flags & NDR_IN) {
20238                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20239                 if (r->in.server) {
20240                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20241                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20242                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20243                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20244                 }
20245                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20246                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20247                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20248                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20249                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20250                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20251                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
20252                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20253         }
20254         if (flags & NDR_OUT) {
20255                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20256         }
20257         return NDR_ERR_SUCCESS;
20258 }
20259
20260 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriver(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriver *r)
20261 {
20262         uint32_t _ptr_server;
20263         TALLOC_CTX *_mem_save_server_0;
20264         if (flags & NDR_IN) {
20265                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20266                 if (_ptr_server) {
20267                         NDR_PULL_ALLOC(ndr, r->in.server);
20268                 } else {
20269                         r->in.server = NULL;
20270                 }
20271                 if (r->in.server) {
20272                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20273                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20274                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20275                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20276                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20277                                 return 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));
20278                         }
20279                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20280                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20281                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20282                 }
20283                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20284                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20285                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20286                         return 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));
20287                 }
20288                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20289                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20290                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
20291                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
20292                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
20293                         return 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));
20294                 }
20295                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
20296                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
20297         }
20298         if (flags & NDR_OUT) {
20299                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20300         }
20301         return NDR_ERR_SUCCESS;
20302 }
20303
20304 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriver(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriver *r)
20305 {
20306         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriver");
20307         ndr->depth++;
20308         if (flags & NDR_SET_VALUES) {
20309                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20310         }
20311         if (flags & NDR_IN) {
20312                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriver");
20313                 ndr->depth++;
20314                 ndr_print_ptr(ndr, "server", r->in.server);
20315                 ndr->depth++;
20316                 if (r->in.server) {
20317                         ndr_print_string(ndr, "server", r->in.server);
20318                 }
20319                 ndr->depth--;
20320                 ndr_print_string(ndr, "architecture", r->in.architecture);
20321                 ndr_print_string(ndr, "driver", r->in.driver);
20322                 ndr->depth--;
20323         }
20324         if (flags & NDR_OUT) {
20325                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriver");
20326                 ndr->depth++;
20327                 ndr_print_WERROR(ndr, "result", r->out.result);
20328                 ndr->depth--;
20329         }
20330         ndr->depth--;
20331 }
20332
20333 static enum ndr_err_code ndr_push_spoolss_AddPrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProcessor *r)
20334 {
20335         if (flags & NDR_IN) {
20336                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20337                 if (r->in.server) {
20338                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20339                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20340                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20341                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20342                 }
20343                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20344                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20345                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
20346                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20347                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20348                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20349                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.path_name, CH_UTF16)));
20350                 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));
20351                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20353                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
20354                 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));
20355         }
20356         if (flags & NDR_OUT) {
20357                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20358         }
20359         return NDR_ERR_SUCCESS;
20360 }
20361
20362 static enum ndr_err_code ndr_pull_spoolss_AddPrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProcessor *r)
20363 {
20364         uint32_t _ptr_server;
20365         TALLOC_CTX *_mem_save_server_0;
20366         if (flags & NDR_IN) {
20367                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20368                 if (_ptr_server) {
20369                         NDR_PULL_ALLOC(ndr, r->in.server);
20370                 } else {
20371                         r->in.server = NULL;
20372                 }
20373                 if (r->in.server) {
20374                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20375                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20376                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20377                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20378                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20379                                 return 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));
20380                         }
20381                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20382                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20383                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20384                 }
20385                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
20386                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
20387                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
20388                         return 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));
20389                 }
20390                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
20391                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
20392                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.path_name));
20393                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.path_name));
20394                 if (ndr_get_array_length(ndr, &r->in.path_name) > ndr_get_array_size(ndr, &r->in.path_name)) {
20395                         return 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));
20396                 }
20397                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.path_name), sizeof(uint16_t)));
20398                 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));
20399                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
20400                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
20401                 if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
20402                         return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.print_processor_name), ndr_get_array_length(ndr, &r->in.print_processor_name));
20403                 }
20404                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
20405                 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));
20406         }
20407         if (flags & NDR_OUT) {
20408                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20409         }
20410         return NDR_ERR_SUCCESS;
20411 }
20412
20413 _PUBLIC_ void ndr_print_spoolss_AddPrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProcessor *r)
20414 {
20415         ndr_print_struct(ndr, name, "spoolss_AddPrintProcessor");
20416         ndr->depth++;
20417         if (flags & NDR_SET_VALUES) {
20418                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20419         }
20420         if (flags & NDR_IN) {
20421                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProcessor");
20422                 ndr->depth++;
20423                 ndr_print_ptr(ndr, "server", r->in.server);
20424                 ndr->depth++;
20425                 if (r->in.server) {
20426                         ndr_print_string(ndr, "server", r->in.server);
20427                 }
20428                 ndr->depth--;
20429                 ndr_print_string(ndr, "architecture", r->in.architecture);
20430                 ndr_print_string(ndr, "path_name", r->in.path_name);
20431                 ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
20432                 ndr->depth--;
20433         }
20434         if (flags & NDR_OUT) {
20435                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProcessor");
20436                 ndr->depth++;
20437                 ndr_print_WERROR(ndr, "result", r->out.result);
20438                 ndr->depth--;
20439         }
20440         ndr->depth--;
20441 }
20442
20443 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcessors *r)
20444 {
20445         if (flags & NDR_IN) {
20446                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
20447                 if (r->in.servername) {
20448                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20449                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20450                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
20451                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20452                 }
20453                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20454                 if (r->in.environment) {
20455                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20456                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20457                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20458                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20459                 }
20460                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20461                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20462                 if (r->in.buffer) {
20463                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20464                 }
20465                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20466         }
20467         if (flags & NDR_OUT) {
20468                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20469                 if (r->out.info) {
20470                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
20471                 }
20472                 if (r->out.needed == NULL) {
20473                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20474                 }
20475                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20476                 if (r->out.count == NULL) {
20477                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20478                 }
20479                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
20480                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20481         }
20482         return NDR_ERR_SUCCESS;
20483 }
20484
20485 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcessors *r)
20486 {
20487         uint32_t _ptr_servername;
20488         uint32_t _ptr_environment;
20489         uint32_t _ptr_buffer;
20490         uint32_t _ptr_info;
20491         TALLOC_CTX *_mem_save_servername_0;
20492         TALLOC_CTX *_mem_save_environment_0;
20493         TALLOC_CTX *_mem_save_buffer_0;
20494         TALLOC_CTX *_mem_save_info_0;
20495         TALLOC_CTX *_mem_save_needed_0;
20496         TALLOC_CTX *_mem_save_count_0;
20497         if (flags & NDR_IN) {
20498                 ZERO_STRUCT(r->out);
20499
20500                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
20501                 if (_ptr_servername) {
20502                         NDR_PULL_ALLOC(ndr, r->in.servername);
20503                 } else {
20504                         r->in.servername = NULL;
20505                 }
20506                 if (r->in.servername) {
20507                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
20508                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
20509                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
20510                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
20511                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
20512                                 return 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));
20513                         }
20514                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
20515                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
20516                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
20517                 }
20518                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20519                 if (_ptr_environment) {
20520                         NDR_PULL_ALLOC(ndr, r->in.environment);
20521                 } else {
20522                         r->in.environment = NULL;
20523                 }
20524                 if (r->in.environment) {
20525                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20526                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20527                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20528                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20529                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20530                                 return 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));
20531                         }
20532                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20533                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20534                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20535                 }
20536                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20537                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20538                 if (_ptr_buffer) {
20539                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20540                 } else {
20541                         r->in.buffer = NULL;
20542                 }
20543                 if (r->in.buffer) {
20544                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20545                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20546                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20547                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20548                 }
20549                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20550                 NDR_PULL_ALLOC(ndr, r->out.needed);
20551                 ZERO_STRUCTP(r->out.needed);
20552                 NDR_PULL_ALLOC(ndr, r->out.count);
20553                 ZERO_STRUCTP(r->out.count);
20554         }
20555         if (flags & NDR_OUT) {
20556                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20557                 if (_ptr_info) {
20558                         NDR_PULL_ALLOC(ndr, r->out.info);
20559                 } else {
20560                         r->out.info = NULL;
20561                 }
20562                 if (r->out.info) {
20563                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20564                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20565                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
20566                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20567                 }
20568                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20569                         NDR_PULL_ALLOC(ndr, r->out.needed);
20570                 }
20571                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20572                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20573                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20574                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20575                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20576                         NDR_PULL_ALLOC(ndr, r->out.count);
20577                 }
20578                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
20579                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
20580                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
20581                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
20582                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20583         }
20584         return NDR_ERR_SUCCESS;
20585 }
20586
20587 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcessors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcessors *r)
20588 {
20589         uint32_t cntr_info_0;
20590         if (flags & NDR_IN) {
20591                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20592                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
20593         }
20594         if (flags & NDR_OUT) {
20595                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20596                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20597                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20598                 }
20599                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20600                         NDR_CHECK(ndr_push_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20601                 }
20602         }
20603         return NDR_ERR_SUCCESS;
20604 }
20605
20606 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcessors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcessors *r)
20607 {
20608         uint32_t cntr_info_0;
20609         TALLOC_CTX *_mem_save_info_0;
20610         if (flags & NDR_IN) {
20611                 ZERO_STRUCT(r->out);
20612
20613                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20614                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
20615         }
20616         if (flags & NDR_OUT) {
20617                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
20618                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20619                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20620                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20621                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
20622                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
20623                 }
20624                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
20625                         NDR_CHECK(ndr_pull_spoolss_PrintProcessorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
20626                 }
20627                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20628         }
20629         return NDR_ERR_SUCCESS;
20630 }
20631
20632 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcessors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcessors *r)
20633 {
20634         uint32_t cntr_info_2;
20635         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcessors");
20636         ndr->depth++;
20637         if (flags & NDR_SET_VALUES) {
20638                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20639         }
20640         if (flags & NDR_IN) {
20641                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcessors");
20642                 ndr->depth++;
20643                 ndr_print_ptr(ndr, "servername", r->in.servername);
20644                 ndr->depth++;
20645                 if (r->in.servername) {
20646                         ndr_print_string(ndr, "servername", r->in.servername);
20647                 }
20648                 ndr->depth--;
20649                 ndr_print_ptr(ndr, "environment", r->in.environment);
20650                 ndr->depth++;
20651                 if (r->in.environment) {
20652                         ndr_print_string(ndr, "environment", r->in.environment);
20653                 }
20654                 ndr->depth--;
20655                 ndr_print_uint32(ndr, "level", r->in.level);
20656                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20657                 ndr->depth++;
20658                 if (r->in.buffer) {
20659                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20660                 }
20661                 ndr->depth--;
20662                 ndr_print_uint32(ndr, "offered", r->in.offered);
20663                 ndr->depth--;
20664         }
20665         if (flags & NDR_OUT) {
20666                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcessors");
20667                 ndr->depth++;
20668                 ndr_print_ptr(ndr, "count", r->out.count);
20669                 ndr->depth++;
20670                 ndr_print_uint32(ndr, "count", *r->out.count);
20671                 ndr->depth--;
20672                 ndr_print_ptr(ndr, "info", r->out.info);
20673                 ndr->depth++;
20674                 ndr_print_ptr(ndr, "info", *r->out.info);
20675                 ndr->depth++;
20676                 if (*r->out.info) {
20677                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
20678                         ndr->depth++;
20679                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
20680                                 char *idx_2=NULL;
20681                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
20682                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
20683                                         ndr_print_spoolss_PrintProcessorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
20684                                         free(idx_2);
20685                                 }
20686                         }
20687                         ndr->depth--;
20688                 }
20689                 ndr->depth--;
20690                 ndr->depth--;
20691                 ndr_print_ptr(ndr, "needed", r->out.needed);
20692                 ndr->depth++;
20693                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20694                 ndr->depth--;
20695                 ndr_print_WERROR(ndr, "result", r->out.result);
20696                 ndr->depth--;
20697         }
20698         ndr->depth--;
20699 }
20700
20701 static enum ndr_err_code ndr_push_spoolss_GetPrintProcessorDirectory(struct ndr_push *ndr, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20702 {
20703         if (flags & NDR_IN) {
20704                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
20705                 if (r->in.server) {
20706                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20707                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20708                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
20709                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20710                 }
20711                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.environment));
20712                 if (r->in.environment) {
20713                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20714                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
20715                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.environment, CH_UTF16)));
20716                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.environment, ndr_charset_length(r->in.environment, CH_UTF16), sizeof(uint16_t), CH_UTF16));
20717                 }
20718                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20719                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
20720                 if (r->in.buffer) {
20721                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
20722                 }
20723                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
20724         }
20725         if (flags & NDR_OUT) {
20726                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
20727                 if (r->out.info) {
20728                         {
20729                                 struct ndr_push *_ndr_info;
20730                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20731                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
20732                                 NDR_CHECK(ndr_push_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20733                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20734                         }
20735                 }
20736                 if (r->out.needed == NULL) {
20737                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20738                 }
20739                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
20740                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20741         }
20742         return NDR_ERR_SUCCESS;
20743 }
20744
20745 static enum ndr_err_code ndr_pull_spoolss_GetPrintProcessorDirectory(struct ndr_pull *ndr, int flags, struct spoolss_GetPrintProcessorDirectory *r)
20746 {
20747         uint32_t _ptr_server;
20748         uint32_t _ptr_environment;
20749         uint32_t _ptr_buffer;
20750         uint32_t _ptr_info;
20751         TALLOC_CTX *_mem_save_server_0;
20752         TALLOC_CTX *_mem_save_environment_0;
20753         TALLOC_CTX *_mem_save_buffer_0;
20754         TALLOC_CTX *_mem_save_info_0;
20755         TALLOC_CTX *_mem_save_needed_0;
20756         if (flags & NDR_IN) {
20757                 ZERO_STRUCT(r->out);
20758
20759                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
20760                 if (_ptr_server) {
20761                         NDR_PULL_ALLOC(ndr, r->in.server);
20762                 } else {
20763                         r->in.server = NULL;
20764                 }
20765                 if (r->in.server) {
20766                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
20767                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
20768                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
20769                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
20770                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
20771                                 return 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));
20772                         }
20773                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
20774                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
20775                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
20776                 }
20777                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_environment));
20778                 if (_ptr_environment) {
20779                         NDR_PULL_ALLOC(ndr, r->in.environment);
20780                 } else {
20781                         r->in.environment = NULL;
20782                 }
20783                 if (r->in.environment) {
20784                         _mem_save_environment_0 = NDR_PULL_GET_MEM_CTX(ndr);
20785                         NDR_PULL_SET_MEM_CTX(ndr, r->in.environment, 0);
20786                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.environment));
20787                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.environment));
20788                         if (ndr_get_array_length(ndr, &r->in.environment) > ndr_get_array_size(ndr, &r->in.environment)) {
20789                                 return 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));
20790                         }
20791                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t)));
20792                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.environment, ndr_get_array_length(ndr, &r->in.environment), sizeof(uint16_t), CH_UTF16));
20793                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_environment_0, 0);
20794                 }
20795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20796                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
20797                 if (_ptr_buffer) {
20798                         NDR_PULL_ALLOC(ndr, r->in.buffer);
20799                 } else {
20800                         r->in.buffer = NULL;
20801                 }
20802                 if (r->in.buffer) {
20803                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
20804                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
20805                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
20806                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
20807                 }
20808                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
20809                 NDR_PULL_ALLOC(ndr, r->out.needed);
20810                 ZERO_STRUCTP(r->out.needed);
20811         }
20812         if (flags & NDR_OUT) {
20813                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
20814                 if (_ptr_info) {
20815                         NDR_PULL_ALLOC(ndr, r->out.info);
20816                 } else {
20817                         r->out.info = NULL;
20818                 }
20819                 if (r->out.info) {
20820                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
20821                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
20822                         {
20823                                 struct ndr_pull *_ndr_info;
20824                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
20825                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
20826                                 NDR_CHECK(ndr_pull_spoolss_PrintProcessorDirectoryInfo(_ndr_info, NDR_SCALARS, r->out.info));
20827                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
20828                         }
20829                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
20830                 }
20831                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20832                         NDR_PULL_ALLOC(ndr, r->out.needed);
20833                 }
20834                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
20835                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
20836                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
20837                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
20838                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20839         }
20840         return NDR_ERR_SUCCESS;
20841 }
20842
20843 _PUBLIC_ void ndr_print_spoolss_GetPrintProcessorDirectory(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrintProcessorDirectory *r)
20844 {
20845         ndr_print_struct(ndr, name, "spoolss_GetPrintProcessorDirectory");
20846         ndr->depth++;
20847         if (flags & NDR_SET_VALUES) {
20848                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20849         }
20850         if (flags & NDR_IN) {
20851                 ndr_print_struct(ndr, "in", "spoolss_GetPrintProcessorDirectory");
20852                 ndr->depth++;
20853                 ndr_print_ptr(ndr, "server", r->in.server);
20854                 ndr->depth++;
20855                 if (r->in.server) {
20856                         ndr_print_string(ndr, "server", r->in.server);
20857                 }
20858                 ndr->depth--;
20859                 ndr_print_ptr(ndr, "environment", r->in.environment);
20860                 ndr->depth++;
20861                 if (r->in.environment) {
20862                         ndr_print_string(ndr, "environment", r->in.environment);
20863                 }
20864                 ndr->depth--;
20865                 ndr_print_uint32(ndr, "level", r->in.level);
20866                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
20867                 ndr->depth++;
20868                 if (r->in.buffer) {
20869                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
20870                 }
20871                 ndr->depth--;
20872                 ndr_print_uint32(ndr, "offered", r->in.offered);
20873                 ndr->depth--;
20874         }
20875         if (flags & NDR_OUT) {
20876                 ndr_print_struct(ndr, "out", "spoolss_GetPrintProcessorDirectory");
20877                 ndr->depth++;
20878                 ndr_print_ptr(ndr, "info", r->out.info);
20879                 ndr->depth++;
20880                 if (r->out.info) {
20881                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
20882                         ndr_print_spoolss_PrintProcessorDirectoryInfo(ndr, "info", r->out.info);
20883                 }
20884                 ndr->depth--;
20885                 ndr_print_ptr(ndr, "needed", r->out.needed);
20886                 ndr->depth++;
20887                 ndr_print_uint32(ndr, "needed", *r->out.needed);
20888                 ndr->depth--;
20889                 ndr_print_WERROR(ndr, "result", r->out.result);
20890                 ndr->depth--;
20891         }
20892         ndr->depth--;
20893 }
20894
20895 static enum ndr_err_code ndr_push_spoolss_StartDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartDocPrinter *r)
20896 {
20897         if (flags & NDR_IN) {
20898                 if (r->in.handle == NULL) {
20899                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20900                 }
20901                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20902                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
20903                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
20904                 NDR_CHECK(ndr_push_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20905         }
20906         if (flags & NDR_OUT) {
20907                 if (r->out.job_id == NULL) {
20908                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20909                 }
20910                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.job_id));
20911                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20912         }
20913         return NDR_ERR_SUCCESS;
20914 }
20915
20916 static enum ndr_err_code ndr_pull_spoolss_StartDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartDocPrinter *r)
20917 {
20918         TALLOC_CTX *_mem_save_handle_0;
20919         TALLOC_CTX *_mem_save_job_id_0;
20920         if (flags & NDR_IN) {
20921                 ZERO_STRUCT(r->out);
20922
20923                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20924                         NDR_PULL_ALLOC(ndr, r->in.handle);
20925                 }
20926                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
20927                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
20928                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20929                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
20930                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
20931                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
20932                 NDR_CHECK(ndr_pull_spoolss_DocumentInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
20933                 NDR_PULL_ALLOC(ndr, r->out.job_id);
20934                 ZERO_STRUCTP(r->out.job_id);
20935         }
20936         if (flags & NDR_OUT) {
20937                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
20938                         NDR_PULL_ALLOC(ndr, r->out.job_id);
20939                 }
20940                 _mem_save_job_id_0 = NDR_PULL_GET_MEM_CTX(ndr);
20941                 NDR_PULL_SET_MEM_CTX(ndr, r->out.job_id, LIBNDR_FLAG_REF_ALLOC);
20942                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.job_id));
20943                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_job_id_0, LIBNDR_FLAG_REF_ALLOC);
20944                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
20945         }
20946         return NDR_ERR_SUCCESS;
20947 }
20948
20949 _PUBLIC_ void ndr_print_spoolss_StartDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartDocPrinter *r)
20950 {
20951         ndr_print_struct(ndr, name, "spoolss_StartDocPrinter");
20952         ndr->depth++;
20953         if (flags & NDR_SET_VALUES) {
20954                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
20955         }
20956         if (flags & NDR_IN) {
20957                 ndr_print_struct(ndr, "in", "spoolss_StartDocPrinter");
20958                 ndr->depth++;
20959                 ndr_print_ptr(ndr, "handle", r->in.handle);
20960                 ndr->depth++;
20961                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
20962                 ndr->depth--;
20963                 ndr_print_uint32(ndr, "level", r->in.level);
20964                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
20965                 ndr_print_spoolss_DocumentInfo(ndr, "info", &r->in.info);
20966                 ndr->depth--;
20967         }
20968         if (flags & NDR_OUT) {
20969                 ndr_print_struct(ndr, "out", "spoolss_StartDocPrinter");
20970                 ndr->depth++;
20971                 ndr_print_ptr(ndr, "job_id", r->out.job_id);
20972                 ndr->depth++;
20973                 ndr_print_uint32(ndr, "job_id", *r->out.job_id);
20974                 ndr->depth--;
20975                 ndr_print_WERROR(ndr, "result", r->out.result);
20976                 ndr->depth--;
20977         }
20978         ndr->depth--;
20979 }
20980
20981 static enum ndr_err_code ndr_push_spoolss_StartPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_StartPagePrinter *r)
20982 {
20983         if (flags & NDR_IN) {
20984                 if (r->in.handle == NULL) {
20985                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
20986                 }
20987                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
20988         }
20989         if (flags & NDR_OUT) {
20990                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
20991         }
20992         return NDR_ERR_SUCCESS;
20993 }
20994
20995 static enum ndr_err_code ndr_pull_spoolss_StartPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_StartPagePrinter *r)
20996 {
20997         TALLOC_CTX *_mem_save_handle_0;
20998         if (flags & NDR_IN) {
20999                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21000                         NDR_PULL_ALLOC(ndr, r->in.handle);
21001                 }
21002                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21003                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21004                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21005                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21006         }
21007         if (flags & NDR_OUT) {
21008                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21009         }
21010         return NDR_ERR_SUCCESS;
21011 }
21012
21013 _PUBLIC_ void ndr_print_spoolss_StartPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_StartPagePrinter *r)
21014 {
21015         ndr_print_struct(ndr, name, "spoolss_StartPagePrinter");
21016         ndr->depth++;
21017         if (flags & NDR_SET_VALUES) {
21018                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21019         }
21020         if (flags & NDR_IN) {
21021                 ndr_print_struct(ndr, "in", "spoolss_StartPagePrinter");
21022                 ndr->depth++;
21023                 ndr_print_ptr(ndr, "handle", r->in.handle);
21024                 ndr->depth++;
21025                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21026                 ndr->depth--;
21027                 ndr->depth--;
21028         }
21029         if (flags & NDR_OUT) {
21030                 ndr_print_struct(ndr, "out", "spoolss_StartPagePrinter");
21031                 ndr->depth++;
21032                 ndr_print_WERROR(ndr, "result", r->out.result);
21033                 ndr->depth--;
21034         }
21035         ndr->depth--;
21036 }
21037
21038 static enum ndr_err_code ndr_push_spoolss_WritePrinter(struct ndr_push *ndr, int flags, const struct spoolss_WritePrinter *r)
21039 {
21040         if (flags & NDR_IN) {
21041                 if (r->in.handle == NULL) {
21042                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21043                 }
21044                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21045                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data.length));
21047         }
21048         if (flags & NDR_OUT) {
21049                 if (r->out.num_written == NULL) {
21050                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21051                 }
21052                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.num_written));
21053                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21054         }
21055         return NDR_ERR_SUCCESS;
21056 }
21057
21058 static enum ndr_err_code ndr_pull_spoolss_WritePrinter(struct ndr_pull *ndr, int flags, struct spoolss_WritePrinter *r)
21059 {
21060         TALLOC_CTX *_mem_save_handle_0;
21061         TALLOC_CTX *_mem_save_num_written_0;
21062         if (flags & NDR_IN) {
21063                 ZERO_STRUCT(r->out);
21064
21065                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21066                         NDR_PULL_ALLOC(ndr, r->in.handle);
21067                 }
21068                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21069                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21070                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21071                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21072                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.data));
21073                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._data_size));
21074                 NDR_PULL_ALLOC(ndr, r->out.num_written);
21075                 ZERO_STRUCTP(r->out.num_written);
21076         }
21077         if (flags & NDR_OUT) {
21078                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21079                         NDR_PULL_ALLOC(ndr, r->out.num_written);
21080                 }
21081                 _mem_save_num_written_0 = NDR_PULL_GET_MEM_CTX(ndr);
21082                 NDR_PULL_SET_MEM_CTX(ndr, r->out.num_written, LIBNDR_FLAG_REF_ALLOC);
21083                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.num_written));
21084                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_num_written_0, LIBNDR_FLAG_REF_ALLOC);
21085                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21086         }
21087         return NDR_ERR_SUCCESS;
21088 }
21089
21090 _PUBLIC_ void ndr_print_spoolss_WritePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WritePrinter *r)
21091 {
21092         ndr_print_struct(ndr, name, "spoolss_WritePrinter");
21093         ndr->depth++;
21094         if (flags & NDR_SET_VALUES) {
21095                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21096         }
21097         if (flags & NDR_IN) {
21098                 ndr_print_struct(ndr, "in", "spoolss_WritePrinter");
21099                 ndr->depth++;
21100                 ndr_print_ptr(ndr, "handle", r->in.handle);
21101                 ndr->depth++;
21102                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21103                 ndr->depth--;
21104                 ndr_print_DATA_BLOB(ndr, "data", r->in.data);
21105                 ndr_print_uint32(ndr, "_data_size", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.data.length:r->in._data_size);
21106                 ndr->depth--;
21107         }
21108         if (flags & NDR_OUT) {
21109                 ndr_print_struct(ndr, "out", "spoolss_WritePrinter");
21110                 ndr->depth++;
21111                 ndr_print_ptr(ndr, "num_written", r->out.num_written);
21112                 ndr->depth++;
21113                 ndr_print_uint32(ndr, "num_written", *r->out.num_written);
21114                 ndr->depth--;
21115                 ndr_print_WERROR(ndr, "result", r->out.result);
21116                 ndr->depth--;
21117         }
21118         ndr->depth--;
21119 }
21120
21121 static enum ndr_err_code ndr_push_spoolss_EndPagePrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndPagePrinter *r)
21122 {
21123         if (flags & NDR_IN) {
21124                 if (r->in.handle == NULL) {
21125                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21126                 }
21127                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21128         }
21129         if (flags & NDR_OUT) {
21130                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21131         }
21132         return NDR_ERR_SUCCESS;
21133 }
21134
21135 static enum ndr_err_code ndr_pull_spoolss_EndPagePrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndPagePrinter *r)
21136 {
21137         TALLOC_CTX *_mem_save_handle_0;
21138         if (flags & NDR_IN) {
21139                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21140                         NDR_PULL_ALLOC(ndr, r->in.handle);
21141                 }
21142                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21143                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21144                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21145                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21146         }
21147         if (flags & NDR_OUT) {
21148                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21149         }
21150         return NDR_ERR_SUCCESS;
21151 }
21152
21153 _PUBLIC_ void ndr_print_spoolss_EndPagePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndPagePrinter *r)
21154 {
21155         ndr_print_struct(ndr, name, "spoolss_EndPagePrinter");
21156         ndr->depth++;
21157         if (flags & NDR_SET_VALUES) {
21158                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21159         }
21160         if (flags & NDR_IN) {
21161                 ndr_print_struct(ndr, "in", "spoolss_EndPagePrinter");
21162                 ndr->depth++;
21163                 ndr_print_ptr(ndr, "handle", r->in.handle);
21164                 ndr->depth++;
21165                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21166                 ndr->depth--;
21167                 ndr->depth--;
21168         }
21169         if (flags & NDR_OUT) {
21170                 ndr_print_struct(ndr, "out", "spoolss_EndPagePrinter");
21171                 ndr->depth++;
21172                 ndr_print_WERROR(ndr, "result", r->out.result);
21173                 ndr->depth--;
21174         }
21175         ndr->depth--;
21176 }
21177
21178 static enum ndr_err_code ndr_push_spoolss_AbortPrinter(struct ndr_push *ndr, int flags, const struct spoolss_AbortPrinter *r)
21179 {
21180         if (flags & NDR_IN) {
21181                 if (r->in.handle == NULL) {
21182                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21183                 }
21184                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21185         }
21186         if (flags & NDR_OUT) {
21187                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21188         }
21189         return NDR_ERR_SUCCESS;
21190 }
21191
21192 static enum ndr_err_code ndr_pull_spoolss_AbortPrinter(struct ndr_pull *ndr, int flags, struct spoolss_AbortPrinter *r)
21193 {
21194         TALLOC_CTX *_mem_save_handle_0;
21195         if (flags & NDR_IN) {
21196                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21197                         NDR_PULL_ALLOC(ndr, r->in.handle);
21198                 }
21199                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21200                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21201                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21202                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21203         }
21204         if (flags & NDR_OUT) {
21205                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21206         }
21207         return NDR_ERR_SUCCESS;
21208 }
21209
21210 _PUBLIC_ void ndr_print_spoolss_AbortPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AbortPrinter *r)
21211 {
21212         ndr_print_struct(ndr, name, "spoolss_AbortPrinter");
21213         ndr->depth++;
21214         if (flags & NDR_SET_VALUES) {
21215                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21216         }
21217         if (flags & NDR_IN) {
21218                 ndr_print_struct(ndr, "in", "spoolss_AbortPrinter");
21219                 ndr->depth++;
21220                 ndr_print_ptr(ndr, "handle", r->in.handle);
21221                 ndr->depth++;
21222                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21223                 ndr->depth--;
21224                 ndr->depth--;
21225         }
21226         if (flags & NDR_OUT) {
21227                 ndr_print_struct(ndr, "out", "spoolss_AbortPrinter");
21228                 ndr->depth++;
21229                 ndr_print_WERROR(ndr, "result", r->out.result);
21230                 ndr->depth--;
21231         }
21232         ndr->depth--;
21233 }
21234
21235 static enum ndr_err_code ndr_push_spoolss_ReadPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReadPrinter *r)
21236 {
21237         if (flags & NDR_IN) {
21238                 if (r->in.handle == NULL) {
21239                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21240                 }
21241                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21242                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21243         }
21244         if (flags & NDR_OUT) {
21245                 if (r->out.data == NULL) {
21246                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21247                 }
21248                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_size));
21249                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_size));
21250                 if (r->out._data_size == NULL) {
21251                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21252                 }
21253                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out._data_size));
21254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21255         }
21256         return NDR_ERR_SUCCESS;
21257 }
21258
21259 static enum ndr_err_code ndr_pull_spoolss_ReadPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReadPrinter *r)
21260 {
21261         TALLOC_CTX *_mem_save_handle_0;
21262         TALLOC_CTX *_mem_save__data_size_0;
21263         if (flags & NDR_IN) {
21264                 ZERO_STRUCT(r->out);
21265
21266                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21267                         NDR_PULL_ALLOC(ndr, r->in.handle);
21268                 }
21269                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21270                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21271                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21272                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21273                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_size));
21274                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_size);
21275                 memset(r->out.data, 0, (r->in.data_size) * sizeof(*r->out.data));
21276                 NDR_PULL_ALLOC(ndr, r->out._data_size);
21277                 ZERO_STRUCTP(r->out._data_size);
21278         }
21279         if (flags & NDR_OUT) {
21280                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
21281                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21282                         NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
21283                 }
21284                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
21285                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21286                         NDR_PULL_ALLOC(ndr, r->out._data_size);
21287                 }
21288                 _mem_save__data_size_0 = NDR_PULL_GET_MEM_CTX(ndr);
21289                 NDR_PULL_SET_MEM_CTX(ndr, r->out._data_size, LIBNDR_FLAG_REF_ALLOC);
21290                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out._data_size));
21291                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save__data_size_0, LIBNDR_FLAG_REF_ALLOC);
21292                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21293                 if (r->out.data) {
21294                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_size));
21295                 }
21296         }
21297         return NDR_ERR_SUCCESS;
21298 }
21299
21300 _PUBLIC_ void ndr_print_spoolss_ReadPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReadPrinter *r)
21301 {
21302         ndr_print_struct(ndr, name, "spoolss_ReadPrinter");
21303         ndr->depth++;
21304         if (flags & NDR_SET_VALUES) {
21305                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21306         }
21307         if (flags & NDR_IN) {
21308                 ndr_print_struct(ndr, "in", "spoolss_ReadPrinter");
21309                 ndr->depth++;
21310                 ndr_print_ptr(ndr, "handle", r->in.handle);
21311                 ndr->depth++;
21312                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21313                 ndr->depth--;
21314                 ndr_print_uint32(ndr, "data_size", r->in.data_size);
21315                 ndr->depth--;
21316         }
21317         if (flags & NDR_OUT) {
21318                 ndr_print_struct(ndr, "out", "spoolss_ReadPrinter");
21319                 ndr->depth++;
21320                 ndr_print_ptr(ndr, "data", r->out.data);
21321                 ndr->depth++;
21322                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_size);
21323                 ndr->depth--;
21324                 ndr_print_ptr(ndr, "_data_size", r->out._data_size);
21325                 ndr->depth++;
21326                 ndr_print_uint32(ndr, "_data_size", *r->out._data_size);
21327                 ndr->depth--;
21328                 ndr_print_WERROR(ndr, "result", r->out.result);
21329                 ndr->depth--;
21330         }
21331         ndr->depth--;
21332 }
21333
21334 static enum ndr_err_code ndr_push_spoolss_EndDocPrinter(struct ndr_push *ndr, int flags, const struct spoolss_EndDocPrinter *r)
21335 {
21336         if (flags & NDR_IN) {
21337                 if (r->in.handle == NULL) {
21338                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21339                 }
21340                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21341         }
21342         if (flags & NDR_OUT) {
21343                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21344         }
21345         return NDR_ERR_SUCCESS;
21346 }
21347
21348 static enum ndr_err_code ndr_pull_spoolss_EndDocPrinter(struct ndr_pull *ndr, int flags, struct spoolss_EndDocPrinter *r)
21349 {
21350         TALLOC_CTX *_mem_save_handle_0;
21351         if (flags & NDR_IN) {
21352                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21353                         NDR_PULL_ALLOC(ndr, r->in.handle);
21354                 }
21355                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21356                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21357                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21358                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21359         }
21360         if (flags & NDR_OUT) {
21361                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21362         }
21363         return NDR_ERR_SUCCESS;
21364 }
21365
21366 _PUBLIC_ void ndr_print_spoolss_EndDocPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EndDocPrinter *r)
21367 {
21368         ndr_print_struct(ndr, name, "spoolss_EndDocPrinter");
21369         ndr->depth++;
21370         if (flags & NDR_SET_VALUES) {
21371                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21372         }
21373         if (flags & NDR_IN) {
21374                 ndr_print_struct(ndr, "in", "spoolss_EndDocPrinter");
21375                 ndr->depth++;
21376                 ndr_print_ptr(ndr, "handle", r->in.handle);
21377                 ndr->depth++;
21378                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21379                 ndr->depth--;
21380                 ndr->depth--;
21381         }
21382         if (flags & NDR_OUT) {
21383                 ndr_print_struct(ndr, "out", "spoolss_EndDocPrinter");
21384                 ndr->depth++;
21385                 ndr_print_WERROR(ndr, "result", r->out.result);
21386                 ndr->depth--;
21387         }
21388         ndr->depth--;
21389 }
21390
21391 static enum ndr_err_code ndr_push_spoolss_AddJob(struct ndr_push *ndr, int flags, const struct spoolss_AddJob *r)
21392 {
21393         if (flags & NDR_IN) {
21394                 if (r->in.handle == NULL) {
21395                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21396                 }
21397                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21398                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21399                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
21400                 if (r->in.buffer) {
21401                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21402                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
21403                 }
21404                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21405         }
21406         if (flags & NDR_OUT) {
21407                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.buffer));
21408                 if (r->out.buffer) {
21409                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21410                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
21411                 }
21412                 if (r->out.needed == NULL) {
21413                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21414                 }
21415                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21416                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21417         }
21418         return NDR_ERR_SUCCESS;
21419 }
21420
21421 static enum ndr_err_code ndr_pull_spoolss_AddJob(struct ndr_pull *ndr, int flags, struct spoolss_AddJob *r)
21422 {
21423         uint32_t _ptr_buffer;
21424         TALLOC_CTX *_mem_save_handle_0;
21425         TALLOC_CTX *_mem_save_buffer_0;
21426         TALLOC_CTX *_mem_save_needed_0;
21427         if (flags & NDR_IN) {
21428                 ZERO_STRUCT(r->out);
21429
21430                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21431                         NDR_PULL_ALLOC(ndr, r->in.handle);
21432                 }
21433                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21434                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21435                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21436                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21437                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
21438                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21439                 if (_ptr_buffer) {
21440                         NDR_PULL_ALLOC(ndr, r->in.buffer);
21441                 } else {
21442                         r->in.buffer = NULL;
21443                 }
21444                 if (r->in.buffer) {
21445                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21446                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
21447                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
21448                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
21449                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
21450                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21451                 }
21452                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21453                 NDR_PULL_ALLOC(ndr, r->out.needed);
21454                 ZERO_STRUCTP(r->out.needed);
21455                 if (r->in.buffer) {
21456                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
21457                 }
21458         }
21459         if (flags & NDR_OUT) {
21460                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
21461                 if (_ptr_buffer) {
21462                         NDR_PULL_ALLOC(ndr, r->out.buffer);
21463                 } else {
21464                         r->out.buffer = NULL;
21465                 }
21466                 if (r->out.buffer) {
21467                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
21468                         NDR_PULL_SET_MEM_CTX(ndr, r->out.buffer, 0);
21469                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
21470                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
21471                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
21472                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
21473                 }
21474                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21475                         NDR_PULL_ALLOC(ndr, r->out.needed);
21476                 }
21477                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21478                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21479                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21480                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21481                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21482                 if (r->out.buffer) {
21483                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
21484                 }
21485         }
21486         return NDR_ERR_SUCCESS;
21487 }
21488
21489 _PUBLIC_ void ndr_print_spoolss_AddJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddJob *r)
21490 {
21491         ndr_print_struct(ndr, name, "spoolss_AddJob");
21492         ndr->depth++;
21493         if (flags & NDR_SET_VALUES) {
21494                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21495         }
21496         if (flags & NDR_IN) {
21497                 ndr_print_struct(ndr, "in", "spoolss_AddJob");
21498                 ndr->depth++;
21499                 ndr_print_ptr(ndr, "handle", r->in.handle);
21500                 ndr->depth++;
21501                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21502                 ndr->depth--;
21503                 ndr_print_uint32(ndr, "level", r->in.level);
21504                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
21505                 ndr->depth++;
21506                 if (r->in.buffer) {
21507                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
21508                 }
21509                 ndr->depth--;
21510                 ndr_print_uint32(ndr, "offered", r->in.offered);
21511                 ndr->depth--;
21512         }
21513         if (flags & NDR_OUT) {
21514                 ndr_print_struct(ndr, "out", "spoolss_AddJob");
21515                 ndr->depth++;
21516                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
21517                 ndr->depth++;
21518                 if (r->out.buffer) {
21519                         ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
21520                 }
21521                 ndr->depth--;
21522                 ndr_print_ptr(ndr, "needed", r->out.needed);
21523                 ndr->depth++;
21524                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21525                 ndr->depth--;
21526                 ndr_print_WERROR(ndr, "result", r->out.result);
21527                 ndr->depth--;
21528         }
21529         ndr->depth--;
21530 }
21531
21532 static enum ndr_err_code ndr_push_spoolss_ScheduleJob(struct ndr_push *ndr, int flags, const struct spoolss_ScheduleJob *r)
21533 {
21534         if (flags & NDR_IN) {
21535                 if (r->in.handle == NULL) {
21536                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21537                 }
21538                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21539                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.jobid));
21540         }
21541         if (flags & NDR_OUT) {
21542                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21543         }
21544         return NDR_ERR_SUCCESS;
21545 }
21546
21547 static enum ndr_err_code ndr_pull_spoolss_ScheduleJob(struct ndr_pull *ndr, int flags, struct spoolss_ScheduleJob *r)
21548 {
21549         TALLOC_CTX *_mem_save_handle_0;
21550         if (flags & NDR_IN) {
21551                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21552                         NDR_PULL_ALLOC(ndr, r->in.handle);
21553                 }
21554                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21555                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21556                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21557                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21558                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.jobid));
21559         }
21560         if (flags & NDR_OUT) {
21561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21562         }
21563         return NDR_ERR_SUCCESS;
21564 }
21565
21566 _PUBLIC_ void ndr_print_spoolss_ScheduleJob(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ScheduleJob *r)
21567 {
21568         ndr_print_struct(ndr, name, "spoolss_ScheduleJob");
21569         ndr->depth++;
21570         if (flags & NDR_SET_VALUES) {
21571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21572         }
21573         if (flags & NDR_IN) {
21574                 ndr_print_struct(ndr, "in", "spoolss_ScheduleJob");
21575                 ndr->depth++;
21576                 ndr_print_ptr(ndr, "handle", r->in.handle);
21577                 ndr->depth++;
21578                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21579                 ndr->depth--;
21580                 ndr_print_uint32(ndr, "jobid", r->in.jobid);
21581                 ndr->depth--;
21582         }
21583         if (flags & NDR_OUT) {
21584                 ndr_print_struct(ndr, "out", "spoolss_ScheduleJob");
21585                 ndr->depth++;
21586                 ndr_print_WERROR(ndr, "result", r->out.result);
21587                 ndr->depth--;
21588         }
21589         ndr->depth--;
21590 }
21591
21592 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_GetPrinterData *r)
21593 {
21594         if (flags & NDR_IN) {
21595                 if (r->in.handle == NULL) {
21596                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21597                 }
21598                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21599                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21600                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21601                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21602                 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));
21603                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
21604         }
21605         if (flags & NDR_OUT) {
21606                 if (r->out.type == NULL) {
21607                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21608                 }
21609                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
21610                 if (r->out.data == NULL) {
21611                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21612                 }
21613                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.data));
21614                 if (r->out.needed == NULL) {
21615                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21616                 }
21617                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
21618                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21619         }
21620         return NDR_ERR_SUCCESS;
21621 }
21622
21623 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct _spoolss_GetPrinterData *r)
21624 {
21625         TALLOC_CTX *_mem_save_handle_0;
21626         TALLOC_CTX *_mem_save_type_0;
21627         TALLOC_CTX *_mem_save_data_0;
21628         TALLOC_CTX *_mem_save_needed_0;
21629         if (flags & NDR_IN) {
21630                 ZERO_STRUCT(r->out);
21631
21632                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21633                         NDR_PULL_ALLOC(ndr, r->in.handle);
21634                 }
21635                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21636                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21637                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21638                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21639                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21640                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21641                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21642                         return 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));
21643                 }
21644                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21645                 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));
21646                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
21647                 NDR_PULL_ALLOC(ndr, r->out.type);
21648                 ZERO_STRUCTP(r->out.type);
21649                 NDR_PULL_ALLOC(ndr, r->out.data);
21650                 ZERO_STRUCTP(r->out.data);
21651                 NDR_PULL_ALLOC(ndr, r->out.needed);
21652                 ZERO_STRUCTP(r->out.needed);
21653         }
21654         if (flags & NDR_OUT) {
21655                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21656                         NDR_PULL_ALLOC(ndr, r->out.type);
21657                 }
21658                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
21659                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
21660                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
21661                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
21662                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21663                         NDR_PULL_ALLOC(ndr, r->out.data);
21664                 }
21665                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21666                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21667                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.data));
21668                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21669                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21670                         NDR_PULL_ALLOC(ndr, r->out.needed);
21671                 }
21672                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
21673                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
21674                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
21675                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
21676                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21677         }
21678         return NDR_ERR_SUCCESS;
21679 }
21680
21681 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_GetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_GetPrinterData *r)
21682 {
21683         if (flags & NDR_IN) {
21684                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21685         }
21686         if (flags & NDR_OUT) {
21687                 if (r->out.data == NULL) {
21688                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21689                 }
21690                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
21691                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21692         }
21693         return NDR_ERR_SUCCESS;
21694 }
21695
21696 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_GetPrinterData(struct ndr_pull *ndr, int flags, struct __spoolss_GetPrinterData *r)
21697 {
21698         TALLOC_CTX *_mem_save_data_0;
21699         if (flags & NDR_IN) {
21700                 ZERO_STRUCT(r->out);
21701
21702                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
21703                 NDR_PULL_ALLOC(ndr, r->out.data);
21704                 ZERO_STRUCTP(r->out.data);
21705         }
21706         if (flags & NDR_OUT) {
21707                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21708                         NDR_PULL_ALLOC(ndr, r->out.data);
21709                 }
21710                 _mem_save_data_0 = NDR_PULL_GET_MEM_CTX(ndr);
21711                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data, LIBNDR_FLAG_REF_ALLOC);
21712                 NDR_CHECK(ndr_pull_set_switch_value(ndr, r->out.data, r->in.type));
21713                 NDR_CHECK(ndr_pull_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21714                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_0, LIBNDR_FLAG_REF_ALLOC);
21715         }
21716         return NDR_ERR_SUCCESS;
21717 }
21718
21719 _PUBLIC_ void ndr_print_spoolss_GetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterData *r)
21720 {
21721         ndr_print_struct(ndr, name, "spoolss_GetPrinterData");
21722         ndr->depth++;
21723         if (flags & NDR_SET_VALUES) {
21724                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21725         }
21726         if (flags & NDR_IN) {
21727                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterData");
21728                 ndr->depth++;
21729                 ndr_print_ptr(ndr, "handle", r->in.handle);
21730                 ndr->depth++;
21731                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21732                 ndr->depth--;
21733                 ndr_print_string(ndr, "value_name", r->in.value_name);
21734                 ndr_print_uint32(ndr, "offered", r->in.offered);
21735                 ndr->depth--;
21736         }
21737         if (flags & NDR_OUT) {
21738                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterData");
21739                 ndr->depth++;
21740                 ndr_print_ptr(ndr, "type", r->out.type);
21741                 ndr->depth++;
21742                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
21743                 ndr->depth--;
21744                 ndr_print_ptr(ndr, "data", r->out.data);
21745                 ndr->depth++;
21746                 ndr_print_set_switch_value(ndr, r->out.data, *r->out.type);
21747                 ndr_print_spoolss_PrinterData(ndr, "data", r->out.data);
21748                 ndr->depth--;
21749                 ndr_print_ptr(ndr, "needed", r->out.needed);
21750                 ndr->depth++;
21751                 ndr_print_uint32(ndr, "needed", *r->out.needed);
21752                 ndr->depth--;
21753                 ndr_print_WERROR(ndr, "result", r->out.result);
21754                 ndr->depth--;
21755         }
21756         ndr->depth--;
21757 }
21758
21759 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct _spoolss_SetPrinterData *r)
21760 {
21761         if (flags & NDR_IN) {
21762                 if (r->in.handle == NULL) {
21763                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21764                 }
21765                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21766                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21767                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
21768                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
21769                 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));
21770                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21771                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.data));
21772                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in._offered));
21773         }
21774         if (flags & NDR_OUT) {
21775                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21776         }
21777         return NDR_ERR_SUCCESS;
21778 }
21779
21780 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_SetPrinterData(struct ndr_push *ndr, int flags, const struct __spoolss_SetPrinterData *r)
21781 {
21782         if (flags & NDR_IN) {
21783                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
21784         }
21785         if (flags & NDR_OUT) {
21786                 if (r->out.data == NULL) {
21787                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21788                 }
21789                 NDR_CHECK(ndr_push_set_switch_value(ndr, r->out.data, r->in.type));
21790                 NDR_CHECK(ndr_push_spoolss_PrinterData(ndr, NDR_SCALARS|NDR_BUFFERS, r->out.data));
21791         }
21792         return NDR_ERR_SUCCESS;
21793 }
21794
21795 static enum ndr_err_code ndr_pull_spoolss_SetPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterData *r)
21796 {
21797         TALLOC_CTX *_mem_save_handle_0;
21798         if (flags & NDR_IN) {
21799                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21800                         NDR_PULL_ALLOC(ndr, r->in.handle);
21801                 }
21802                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21803                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21804                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21805                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21806                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
21807                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
21808                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
21809                         return 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));
21810                 }
21811                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
21812                 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));
21813                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
21814                 {
21815                         struct ndr_pull *_ndr_data;
21816                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_data, 4, -1));
21817                         NDR_CHECK(ndr_pull_set_switch_value(_ndr_data, &r->in.data, r->in.type));
21818                         NDR_CHECK(ndr_pull_spoolss_PrinterData(_ndr_data, NDR_SCALARS|NDR_BUFFERS, &r->in.data));
21819                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_data, 4, -1));
21820                 }
21821                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._offered));
21822         }
21823         if (flags & NDR_OUT) {
21824                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21825         }
21826         return NDR_ERR_SUCCESS;
21827 }
21828
21829 _PUBLIC_ void ndr_print_spoolss_SetPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterData *r)
21830 {
21831         ndr_print_struct(ndr, name, "spoolss_SetPrinterData");
21832         ndr->depth++;
21833         if (flags & NDR_SET_VALUES) {
21834                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21835         }
21836         if (flags & NDR_IN) {
21837                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterData");
21838                 ndr->depth++;
21839                 ndr_print_ptr(ndr, "handle", r->in.handle);
21840                 ndr->depth++;
21841                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21842                 ndr->depth--;
21843                 ndr_print_string(ndr, "value_name", r->in.value_name);
21844                 ndr_print_winreg_Type(ndr, "type", r->in.type);
21845                 ndr_print_set_switch_value(ndr, &r->in.data, r->in.type);
21846                 ndr_print_spoolss_PrinterData(ndr, "data", &r->in.data);
21847                 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);
21848                 ndr->depth--;
21849         }
21850         if (flags & NDR_OUT) {
21851                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterData");
21852                 ndr->depth++;
21853                 ndr_print_WERROR(ndr, "result", r->out.result);
21854                 ndr->depth--;
21855         }
21856         ndr->depth--;
21857 }
21858
21859 static enum ndr_err_code ndr_push_spoolss_WaitForPrinterChange(struct ndr_push *ndr, int flags, const struct spoolss_WaitForPrinterChange *r)
21860 {
21861         if (flags & NDR_IN) {
21862         }
21863         if (flags & NDR_OUT) {
21864                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21865         }
21866         return NDR_ERR_SUCCESS;
21867 }
21868
21869 static enum ndr_err_code ndr_pull_spoolss_WaitForPrinterChange(struct ndr_pull *ndr, int flags, struct spoolss_WaitForPrinterChange *r)
21870 {
21871         if (flags & NDR_IN) {
21872         }
21873         if (flags & NDR_OUT) {
21874                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21875         }
21876         return NDR_ERR_SUCCESS;
21877 }
21878
21879 _PUBLIC_ void ndr_print_spoolss_WaitForPrinterChange(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_WaitForPrinterChange *r)
21880 {
21881         ndr_print_struct(ndr, name, "spoolss_WaitForPrinterChange");
21882         ndr->depth++;
21883         if (flags & NDR_SET_VALUES) {
21884                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21885         }
21886         if (flags & NDR_IN) {
21887                 ndr_print_struct(ndr, "in", "spoolss_WaitForPrinterChange");
21888                 ndr->depth++;
21889                 ndr->depth--;
21890         }
21891         if (flags & NDR_OUT) {
21892                 ndr_print_struct(ndr, "out", "spoolss_WaitForPrinterChange");
21893                 ndr->depth++;
21894                 ndr_print_WERROR(ndr, "result", r->out.result);
21895                 ndr->depth--;
21896         }
21897         ndr->depth--;
21898 }
21899
21900 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ClosePrinter *r)
21901 {
21902         if (flags & NDR_IN) {
21903                 if (r->in.handle == NULL) {
21904                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21905                 }
21906                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21907         }
21908         if (flags & NDR_OUT) {
21909                 if (r->out.handle == NULL) {
21910                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21911                 }
21912                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21913                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21914         }
21915         return NDR_ERR_SUCCESS;
21916 }
21917
21918 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ClosePrinter *r)
21919 {
21920         TALLOC_CTX *_mem_save_handle_0;
21921         if (flags & NDR_IN) {
21922                 ZERO_STRUCT(r->out);
21923
21924                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21925                         NDR_PULL_ALLOC(ndr, r->in.handle);
21926                 }
21927                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21928                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
21929                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21930                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21931                 NDR_PULL_ALLOC(ndr, r->out.handle);
21932                 *r->out.handle = *r->in.handle;
21933         }
21934         if (flags & NDR_OUT) {
21935                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21936                         NDR_PULL_ALLOC(ndr, r->out.handle);
21937                 }
21938                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
21939                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
21940                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
21941                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
21942                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
21943         }
21944         return NDR_ERR_SUCCESS;
21945 }
21946
21947 _PUBLIC_ void ndr_print_spoolss_ClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ClosePrinter *r)
21948 {
21949         ndr_print_struct(ndr, name, "spoolss_ClosePrinter");
21950         ndr->depth++;
21951         if (flags & NDR_SET_VALUES) {
21952                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
21953         }
21954         if (flags & NDR_IN) {
21955                 ndr_print_struct(ndr, "in", "spoolss_ClosePrinter");
21956                 ndr->depth++;
21957                 ndr_print_ptr(ndr, "handle", r->in.handle);
21958                 ndr->depth++;
21959                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
21960                 ndr->depth--;
21961                 ndr->depth--;
21962         }
21963         if (flags & NDR_OUT) {
21964                 ndr_print_struct(ndr, "out", "spoolss_ClosePrinter");
21965                 ndr->depth++;
21966                 ndr_print_ptr(ndr, "handle", r->out.handle);
21967                 ndr->depth++;
21968                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
21969                 ndr->depth--;
21970                 ndr_print_WERROR(ndr, "result", r->out.result);
21971                 ndr->depth--;
21972         }
21973         ndr->depth--;
21974 }
21975
21976 static enum ndr_err_code ndr_push_spoolss_AddForm(struct ndr_push *ndr, int flags, const struct spoolss_AddForm *r)
21977 {
21978         if (flags & NDR_IN) {
21979                 if (r->in.handle == NULL) {
21980                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
21981                 }
21982                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
21983                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
21984                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
21985                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
21986         }
21987         if (flags & NDR_OUT) {
21988                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
21989         }
21990         return NDR_ERR_SUCCESS;
21991 }
21992
21993 static enum ndr_err_code ndr_pull_spoolss_AddForm(struct ndr_pull *ndr, int flags, struct spoolss_AddForm *r)
21994 {
21995         TALLOC_CTX *_mem_save_handle_0;
21996         if (flags & NDR_IN) {
21997                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
21998                         NDR_PULL_ALLOC(ndr, r->in.handle);
21999                 }
22000                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22001                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22002                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22003                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22004                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22005                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22006                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22007         }
22008         if (flags & NDR_OUT) {
22009                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22010         }
22011         return NDR_ERR_SUCCESS;
22012 }
22013
22014 _PUBLIC_ void ndr_print_spoolss_AddForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddForm *r)
22015 {
22016         ndr_print_struct(ndr, name, "spoolss_AddForm");
22017         ndr->depth++;
22018         if (flags & NDR_SET_VALUES) {
22019                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22020         }
22021         if (flags & NDR_IN) {
22022                 ndr_print_struct(ndr, "in", "spoolss_AddForm");
22023                 ndr->depth++;
22024                 ndr_print_ptr(ndr, "handle", r->in.handle);
22025                 ndr->depth++;
22026                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22027                 ndr->depth--;
22028                 ndr_print_uint32(ndr, "level", r->in.level);
22029                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22030                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22031                 ndr->depth--;
22032         }
22033         if (flags & NDR_OUT) {
22034                 ndr_print_struct(ndr, "out", "spoolss_AddForm");
22035                 ndr->depth++;
22036                 ndr_print_WERROR(ndr, "result", r->out.result);
22037                 ndr->depth--;
22038         }
22039         ndr->depth--;
22040 }
22041
22042 static enum ndr_err_code ndr_push_spoolss_DeleteForm(struct ndr_push *ndr, int flags, const struct spoolss_DeleteForm *r)
22043 {
22044         if (flags & NDR_IN) {
22045                 if (r->in.handle == NULL) {
22046                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22047                 }
22048                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22049                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22050                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22051                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22052                 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));
22053         }
22054         if (flags & NDR_OUT) {
22055                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22056         }
22057         return NDR_ERR_SUCCESS;
22058 }
22059
22060 static enum ndr_err_code ndr_pull_spoolss_DeleteForm(struct ndr_pull *ndr, int flags, struct spoolss_DeleteForm *r)
22061 {
22062         TALLOC_CTX *_mem_save_handle_0;
22063         if (flags & NDR_IN) {
22064                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22065                         NDR_PULL_ALLOC(ndr, r->in.handle);
22066                 }
22067                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22068                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22069                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22070                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22071                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22072                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22073                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22074                         return 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));
22075                 }
22076                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22077                 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));
22078         }
22079         if (flags & NDR_OUT) {
22080                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22081         }
22082         return NDR_ERR_SUCCESS;
22083 }
22084
22085 _PUBLIC_ void ndr_print_spoolss_DeleteForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteForm *r)
22086 {
22087         ndr_print_struct(ndr, name, "spoolss_DeleteForm");
22088         ndr->depth++;
22089         if (flags & NDR_SET_VALUES) {
22090                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22091         }
22092         if (flags & NDR_IN) {
22093                 ndr_print_struct(ndr, "in", "spoolss_DeleteForm");
22094                 ndr->depth++;
22095                 ndr_print_ptr(ndr, "handle", r->in.handle);
22096                 ndr->depth++;
22097                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22098                 ndr->depth--;
22099                 ndr_print_string(ndr, "form_name", r->in.form_name);
22100                 ndr->depth--;
22101         }
22102         if (flags & NDR_OUT) {
22103                 ndr_print_struct(ndr, "out", "spoolss_DeleteForm");
22104                 ndr->depth++;
22105                 ndr_print_WERROR(ndr, "result", r->out.result);
22106                 ndr->depth--;
22107         }
22108         ndr->depth--;
22109 }
22110
22111 static enum ndr_err_code ndr_push_spoolss_GetForm(struct ndr_push *ndr, int flags, const struct spoolss_GetForm *r)
22112 {
22113         if (flags & NDR_IN) {
22114                 if (r->in.handle == NULL) {
22115                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22116                 }
22117                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22118                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22119                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22120                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22121                 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));
22122                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22123                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22124                 if (r->in.buffer) {
22125                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22126                 }
22127                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22128         }
22129         if (flags & NDR_OUT) {
22130                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22131                 if (r->out.info) {
22132                         {
22133                                 struct ndr_push *_ndr_info;
22134                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22135                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
22136                                 NDR_CHECK(ndr_push_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22137                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22138                         }
22139                 }
22140                 if (r->out.needed == NULL) {
22141                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22142                 }
22143                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22145         }
22146         return NDR_ERR_SUCCESS;
22147 }
22148
22149 static enum ndr_err_code ndr_pull_spoolss_GetForm(struct ndr_pull *ndr, int flags, struct spoolss_GetForm *r)
22150 {
22151         uint32_t _ptr_buffer;
22152         uint32_t _ptr_info;
22153         TALLOC_CTX *_mem_save_handle_0;
22154         TALLOC_CTX *_mem_save_buffer_0;
22155         TALLOC_CTX *_mem_save_info_0;
22156         TALLOC_CTX *_mem_save_needed_0;
22157         if (flags & NDR_IN) {
22158                 ZERO_STRUCT(r->out);
22159
22160                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22161                         NDR_PULL_ALLOC(ndr, r->in.handle);
22162                 }
22163                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22164                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22165                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22166                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22167                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22168                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22169                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22170                         return 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));
22171                 }
22172                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22173                 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));
22174                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22175                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22176                 if (_ptr_buffer) {
22177                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22178                 } else {
22179                         r->in.buffer = NULL;
22180                 }
22181                 if (r->in.buffer) {
22182                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22183                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22184                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22185                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22186                 }
22187                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22188                 NDR_PULL_ALLOC(ndr, r->out.needed);
22189                 ZERO_STRUCTP(r->out.needed);
22190         }
22191         if (flags & NDR_OUT) {
22192                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22193                 if (_ptr_info) {
22194                         NDR_PULL_ALLOC(ndr, r->out.info);
22195                 } else {
22196                         r->out.info = NULL;
22197                 }
22198                 if (r->out.info) {
22199                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22200                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22201                         {
22202                                 struct ndr_pull *_ndr_info;
22203                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
22204                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
22205                                 NDR_CHECK(ndr_pull_spoolss_FormInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
22206                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
22207                         }
22208                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22209                 }
22210                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22211                         NDR_PULL_ALLOC(ndr, r->out.needed);
22212                 }
22213                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22214                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22215                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22216                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22217                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22218         }
22219         return NDR_ERR_SUCCESS;
22220 }
22221
22222 _PUBLIC_ void ndr_print_spoolss_GetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetForm *r)
22223 {
22224         ndr_print_struct(ndr, name, "spoolss_GetForm");
22225         ndr->depth++;
22226         if (flags & NDR_SET_VALUES) {
22227                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22228         }
22229         if (flags & NDR_IN) {
22230                 ndr_print_struct(ndr, "in", "spoolss_GetForm");
22231                 ndr->depth++;
22232                 ndr_print_ptr(ndr, "handle", r->in.handle);
22233                 ndr->depth++;
22234                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22235                 ndr->depth--;
22236                 ndr_print_string(ndr, "form_name", r->in.form_name);
22237                 ndr_print_uint32(ndr, "level", r->in.level);
22238                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22239                 ndr->depth++;
22240                 if (r->in.buffer) {
22241                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22242                 }
22243                 ndr->depth--;
22244                 ndr_print_uint32(ndr, "offered", r->in.offered);
22245                 ndr->depth--;
22246         }
22247         if (flags & NDR_OUT) {
22248                 ndr_print_struct(ndr, "out", "spoolss_GetForm");
22249                 ndr->depth++;
22250                 ndr_print_ptr(ndr, "info", r->out.info);
22251                 ndr->depth++;
22252                 if (r->out.info) {
22253                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
22254                         ndr_print_spoolss_FormInfo(ndr, "info", r->out.info);
22255                 }
22256                 ndr->depth--;
22257                 ndr_print_ptr(ndr, "needed", r->out.needed);
22258                 ndr->depth++;
22259                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22260                 ndr->depth--;
22261                 ndr_print_WERROR(ndr, "result", r->out.result);
22262                 ndr->depth--;
22263         }
22264         ndr->depth--;
22265 }
22266
22267 static enum ndr_err_code ndr_push_spoolss_SetForm(struct ndr_push *ndr, int flags, const struct spoolss_SetForm *r)
22268 {
22269         if (flags & NDR_IN) {
22270                 if (r->in.handle == NULL) {
22271                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22272                 }
22273                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22274                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22275                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22276                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.form_name, CH_UTF16)));
22277                 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));
22278                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22279                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.level));
22280                 NDR_CHECK(ndr_push_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22281         }
22282         if (flags & NDR_OUT) {
22283                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22284         }
22285         return NDR_ERR_SUCCESS;
22286 }
22287
22288 static enum ndr_err_code ndr_pull_spoolss_SetForm(struct ndr_pull *ndr, int flags, struct spoolss_SetForm *r)
22289 {
22290         TALLOC_CTX *_mem_save_handle_0;
22291         if (flags & NDR_IN) {
22292                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22293                         NDR_PULL_ALLOC(ndr, r->in.handle);
22294                 }
22295                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22296                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22297                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22298                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22299                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.form_name));
22300                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.form_name));
22301                 if (ndr_get_array_length(ndr, &r->in.form_name) > ndr_get_array_size(ndr, &r->in.form_name)) {
22302                         return 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));
22303                 }
22304                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.form_name), sizeof(uint16_t)));
22305                 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));
22306                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22307                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.level));
22308                 NDR_CHECK(ndr_pull_spoolss_AddFormInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
22309         }
22310         if (flags & NDR_OUT) {
22311                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22312         }
22313         return NDR_ERR_SUCCESS;
22314 }
22315
22316 _PUBLIC_ void ndr_print_spoolss_SetForm(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetForm *r)
22317 {
22318         ndr_print_struct(ndr, name, "spoolss_SetForm");
22319         ndr->depth++;
22320         if (flags & NDR_SET_VALUES) {
22321                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22322         }
22323         if (flags & NDR_IN) {
22324                 ndr_print_struct(ndr, "in", "spoolss_SetForm");
22325                 ndr->depth++;
22326                 ndr_print_ptr(ndr, "handle", r->in.handle);
22327                 ndr->depth++;
22328                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22329                 ndr->depth--;
22330                 ndr_print_string(ndr, "form_name", r->in.form_name);
22331                 ndr_print_uint32(ndr, "level", r->in.level);
22332                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.level);
22333                 ndr_print_spoolss_AddFormInfo(ndr, "info", &r->in.info);
22334                 ndr->depth--;
22335         }
22336         if (flags & NDR_OUT) {
22337                 ndr_print_struct(ndr, "out", "spoolss_SetForm");
22338                 ndr->depth++;
22339                 ndr_print_WERROR(ndr, "result", r->out.result);
22340                 ndr->depth--;
22341         }
22342         ndr->depth--;
22343 }
22344
22345 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct _spoolss_EnumForms *r)
22346 {
22347         if (flags & NDR_IN) {
22348                 if (r->in.handle == NULL) {
22349                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22350                 }
22351                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22352                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22353                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22354                 if (r->in.buffer) {
22355                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22356                 }
22357                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22358         }
22359         if (flags & NDR_OUT) {
22360                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22361                 if (r->out.info) {
22362                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22363                 }
22364                 if (r->out.needed == NULL) {
22365                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22366                 }
22367                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22368                 if (r->out.count == NULL) {
22369                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22370                 }
22371                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22372                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22373         }
22374         return NDR_ERR_SUCCESS;
22375 }
22376
22377 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct _spoolss_EnumForms *r)
22378 {
22379         uint32_t _ptr_buffer;
22380         uint32_t _ptr_info;
22381         TALLOC_CTX *_mem_save_handle_0;
22382         TALLOC_CTX *_mem_save_buffer_0;
22383         TALLOC_CTX *_mem_save_info_0;
22384         TALLOC_CTX *_mem_save_needed_0;
22385         TALLOC_CTX *_mem_save_count_0;
22386         if (flags & NDR_IN) {
22387                 ZERO_STRUCT(r->out);
22388
22389                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22390                         NDR_PULL_ALLOC(ndr, r->in.handle);
22391                 }
22392                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
22393                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
22394                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
22395                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
22396                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22397                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22398                 if (_ptr_buffer) {
22399                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22400                 } else {
22401                         r->in.buffer = NULL;
22402                 }
22403                 if (r->in.buffer) {
22404                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22405                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22406                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22407                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22408                 }
22409                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22410                 NDR_PULL_ALLOC(ndr, r->out.needed);
22411                 ZERO_STRUCTP(r->out.needed);
22412                 NDR_PULL_ALLOC(ndr, r->out.count);
22413                 ZERO_STRUCTP(r->out.count);
22414         }
22415         if (flags & NDR_OUT) {
22416                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22417                 if (_ptr_info) {
22418                         NDR_PULL_ALLOC(ndr, r->out.info);
22419                 } else {
22420                         r->out.info = NULL;
22421                 }
22422                 if (r->out.info) {
22423                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22424                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22425                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22426                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22427                 }
22428                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22429                         NDR_PULL_ALLOC(ndr, r->out.needed);
22430                 }
22431                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22432                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22433                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22434                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22435                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22436                         NDR_PULL_ALLOC(ndr, r->out.count);
22437                 }
22438                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22439                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22440                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22441                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22442                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22443         }
22444         return NDR_ERR_SUCCESS;
22445 }
22446
22447 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumForms(struct ndr_push *ndr, int flags, const struct __spoolss_EnumForms *r)
22448 {
22449         uint32_t cntr_info_0;
22450         if (flags & NDR_IN) {
22451                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22452                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22453         }
22454         if (flags & NDR_OUT) {
22455                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22456                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22457                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22458                 }
22459                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22460                         NDR_CHECK(ndr_push_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22461                 }
22462         }
22463         return NDR_ERR_SUCCESS;
22464 }
22465
22466 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumForms(struct ndr_pull *ndr, int flags, struct __spoolss_EnumForms *r)
22467 {
22468         uint32_t cntr_info_0;
22469         TALLOC_CTX *_mem_save_info_0;
22470         if (flags & NDR_IN) {
22471                 ZERO_STRUCT(r->out);
22472
22473                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22474                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22475         }
22476         if (flags & NDR_OUT) {
22477                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22478                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22479                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22480                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22481                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22482                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22483                 }
22484                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22485                         NDR_CHECK(ndr_pull_spoolss_FormInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22486                 }
22487                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22488         }
22489         return NDR_ERR_SUCCESS;
22490 }
22491
22492 _PUBLIC_ void ndr_print_spoolss_EnumForms(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumForms *r)
22493 {
22494         uint32_t cntr_info_2;
22495         ndr_print_struct(ndr, name, "spoolss_EnumForms");
22496         ndr->depth++;
22497         if (flags & NDR_SET_VALUES) {
22498                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22499         }
22500         if (flags & NDR_IN) {
22501                 ndr_print_struct(ndr, "in", "spoolss_EnumForms");
22502                 ndr->depth++;
22503                 ndr_print_ptr(ndr, "handle", r->in.handle);
22504                 ndr->depth++;
22505                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
22506                 ndr->depth--;
22507                 ndr_print_uint32(ndr, "level", r->in.level);
22508                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22509                 ndr->depth++;
22510                 if (r->in.buffer) {
22511                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22512                 }
22513                 ndr->depth--;
22514                 ndr_print_uint32(ndr, "offered", r->in.offered);
22515                 ndr->depth--;
22516         }
22517         if (flags & NDR_OUT) {
22518                 ndr_print_struct(ndr, "out", "spoolss_EnumForms");
22519                 ndr->depth++;
22520                 ndr_print_ptr(ndr, "count", r->out.count);
22521                 ndr->depth++;
22522                 ndr_print_uint32(ndr, "count", *r->out.count);
22523                 ndr->depth--;
22524                 ndr_print_ptr(ndr, "info", r->out.info);
22525                 ndr->depth++;
22526                 ndr_print_ptr(ndr, "info", *r->out.info);
22527                 ndr->depth++;
22528                 if (*r->out.info) {
22529                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22530                         ndr->depth++;
22531                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22532                                 char *idx_2=NULL;
22533                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22534                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22535                                         ndr_print_spoolss_FormInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22536                                         free(idx_2);
22537                                 }
22538                         }
22539                         ndr->depth--;
22540                 }
22541                 ndr->depth--;
22542                 ndr->depth--;
22543                 ndr_print_ptr(ndr, "needed", r->out.needed);
22544                 ndr->depth++;
22545                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22546                 ndr->depth--;
22547                 ndr_print_WERROR(ndr, "result", r->out.result);
22548                 ndr->depth--;
22549         }
22550         ndr->depth--;
22551 }
22552
22553 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPorts *r)
22554 {
22555         if (flags & NDR_IN) {
22556                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22557                 if (r->in.servername) {
22558                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22559                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22560                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22561                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22562                 }
22563                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22564                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22565                 if (r->in.buffer) {
22566                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22567                 }
22568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22569         }
22570         if (flags & NDR_OUT) {
22571                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22572                 if (r->out.info) {
22573                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22574                 }
22575                 if (r->out.needed == NULL) {
22576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22577                 }
22578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22579                 if (r->out.count == NULL) {
22580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22581                 }
22582                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22583                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22584         }
22585         return NDR_ERR_SUCCESS;
22586 }
22587
22588 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPorts *r)
22589 {
22590         uint32_t _ptr_servername;
22591         uint32_t _ptr_buffer;
22592         uint32_t _ptr_info;
22593         TALLOC_CTX *_mem_save_servername_0;
22594         TALLOC_CTX *_mem_save_buffer_0;
22595         TALLOC_CTX *_mem_save_info_0;
22596         TALLOC_CTX *_mem_save_needed_0;
22597         TALLOC_CTX *_mem_save_count_0;
22598         if (flags & NDR_IN) {
22599                 ZERO_STRUCT(r->out);
22600
22601                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22602                 if (_ptr_servername) {
22603                         NDR_PULL_ALLOC(ndr, r->in.servername);
22604                 } else {
22605                         r->in.servername = NULL;
22606                 }
22607                 if (r->in.servername) {
22608                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22609                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22610                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22611                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22612                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22613                                 return 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));
22614                         }
22615                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22616                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22617                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22618                 }
22619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22620                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22621                 if (_ptr_buffer) {
22622                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22623                 } else {
22624                         r->in.buffer = NULL;
22625                 }
22626                 if (r->in.buffer) {
22627                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22628                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22629                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22630                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22631                 }
22632                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22633                 NDR_PULL_ALLOC(ndr, r->out.needed);
22634                 ZERO_STRUCTP(r->out.needed);
22635                 NDR_PULL_ALLOC(ndr, r->out.count);
22636                 ZERO_STRUCTP(r->out.count);
22637         }
22638         if (flags & NDR_OUT) {
22639                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22640                 if (_ptr_info) {
22641                         NDR_PULL_ALLOC(ndr, r->out.info);
22642                 } else {
22643                         r->out.info = NULL;
22644                 }
22645                 if (r->out.info) {
22646                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22647                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22648                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22649                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22650                 }
22651                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22652                         NDR_PULL_ALLOC(ndr, r->out.needed);
22653                 }
22654                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22655                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22656                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22657                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22658                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22659                         NDR_PULL_ALLOC(ndr, r->out.count);
22660                 }
22661                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22662                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22663                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22664                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22665                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22666         }
22667         return NDR_ERR_SUCCESS;
22668 }
22669
22670 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPorts(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPorts *r)
22671 {
22672         uint32_t cntr_info_0;
22673         if (flags & NDR_IN) {
22674                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22675                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22676         }
22677         if (flags & NDR_OUT) {
22678                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22679                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22680                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22681                 }
22682                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22683                         NDR_CHECK(ndr_push_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22684                 }
22685         }
22686         return NDR_ERR_SUCCESS;
22687 }
22688
22689 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPorts(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPorts *r)
22690 {
22691         uint32_t cntr_info_0;
22692         TALLOC_CTX *_mem_save_info_0;
22693         if (flags & NDR_IN) {
22694                 ZERO_STRUCT(r->out);
22695
22696                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22697                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22698         }
22699         if (flags & NDR_OUT) {
22700                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22701                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22702                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22703                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22704                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22705                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22706                 }
22707                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22708                         NDR_CHECK(ndr_pull_spoolss_PortInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22709                 }
22710                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22711         }
22712         return NDR_ERR_SUCCESS;
22713 }
22714
22715 _PUBLIC_ void ndr_print_spoolss_EnumPorts(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPorts *r)
22716 {
22717         uint32_t cntr_info_2;
22718         ndr_print_struct(ndr, name, "spoolss_EnumPorts");
22719         ndr->depth++;
22720         if (flags & NDR_SET_VALUES) {
22721                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22722         }
22723         if (flags & NDR_IN) {
22724                 ndr_print_struct(ndr, "in", "spoolss_EnumPorts");
22725                 ndr->depth++;
22726                 ndr_print_ptr(ndr, "servername", r->in.servername);
22727                 ndr->depth++;
22728                 if (r->in.servername) {
22729                         ndr_print_string(ndr, "servername", r->in.servername);
22730                 }
22731                 ndr->depth--;
22732                 ndr_print_uint32(ndr, "level", r->in.level);
22733                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22734                 ndr->depth++;
22735                 if (r->in.buffer) {
22736                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22737                 }
22738                 ndr->depth--;
22739                 ndr_print_uint32(ndr, "offered", r->in.offered);
22740                 ndr->depth--;
22741         }
22742         if (flags & NDR_OUT) {
22743                 ndr_print_struct(ndr, "out", "spoolss_EnumPorts");
22744                 ndr->depth++;
22745                 ndr_print_ptr(ndr, "count", r->out.count);
22746                 ndr->depth++;
22747                 ndr_print_uint32(ndr, "count", *r->out.count);
22748                 ndr->depth--;
22749                 ndr_print_ptr(ndr, "info", r->out.info);
22750                 ndr->depth++;
22751                 ndr_print_ptr(ndr, "info", *r->out.info);
22752                 ndr->depth++;
22753                 if (*r->out.info) {
22754                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22755                         ndr->depth++;
22756                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22757                                 char *idx_2=NULL;
22758                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22759                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22760                                         ndr_print_spoolss_PortInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22761                                         free(idx_2);
22762                                 }
22763                         }
22764                         ndr->depth--;
22765                 }
22766                 ndr->depth--;
22767                 ndr->depth--;
22768                 ndr_print_ptr(ndr, "needed", r->out.needed);
22769                 ndr->depth++;
22770                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22771                 ndr->depth--;
22772                 ndr_print_WERROR(ndr, "result", r->out.result);
22773                 ndr->depth--;
22774         }
22775         ndr->depth--;
22776 }
22777
22778 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct _spoolss_EnumMonitors *r)
22779 {
22780         if (flags & NDR_IN) {
22781                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
22782                 if (r->in.servername) {
22783                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22784                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
22785                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
22786                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
22787                 }
22788                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22789                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
22790                 if (r->in.buffer) {
22791                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
22792                 }
22793                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
22794         }
22795         if (flags & NDR_OUT) {
22796                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
22797                 if (r->out.info) {
22798                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
22799                 }
22800                 if (r->out.needed == NULL) {
22801                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22802                 }
22803                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
22804                 if (r->out.count == NULL) {
22805                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
22806                 }
22807                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
22808                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
22809         }
22810         return NDR_ERR_SUCCESS;
22811 }
22812
22813 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct _spoolss_EnumMonitors *r)
22814 {
22815         uint32_t _ptr_servername;
22816         uint32_t _ptr_buffer;
22817         uint32_t _ptr_info;
22818         TALLOC_CTX *_mem_save_servername_0;
22819         TALLOC_CTX *_mem_save_buffer_0;
22820         TALLOC_CTX *_mem_save_info_0;
22821         TALLOC_CTX *_mem_save_needed_0;
22822         TALLOC_CTX *_mem_save_count_0;
22823         if (flags & NDR_IN) {
22824                 ZERO_STRUCT(r->out);
22825
22826                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
22827                 if (_ptr_servername) {
22828                         NDR_PULL_ALLOC(ndr, r->in.servername);
22829                 } else {
22830                         r->in.servername = NULL;
22831                 }
22832                 if (r->in.servername) {
22833                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
22834                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
22835                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
22836                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
22837                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
22838                                 return 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));
22839                         }
22840                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
22841                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
22842                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
22843                 }
22844                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22845                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
22846                 if (_ptr_buffer) {
22847                         NDR_PULL_ALLOC(ndr, r->in.buffer);
22848                 } else {
22849                         r->in.buffer = NULL;
22850                 }
22851                 if (r->in.buffer) {
22852                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
22853                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
22854                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
22855                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
22856                 }
22857                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
22858                 NDR_PULL_ALLOC(ndr, r->out.needed);
22859                 ZERO_STRUCTP(r->out.needed);
22860                 NDR_PULL_ALLOC(ndr, r->out.count);
22861                 ZERO_STRUCTP(r->out.count);
22862         }
22863         if (flags & NDR_OUT) {
22864                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
22865                 if (_ptr_info) {
22866                         NDR_PULL_ALLOC(ndr, r->out.info);
22867                 } else {
22868                         r->out.info = NULL;
22869                 }
22870                 if (r->out.info) {
22871                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22872                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22873                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
22874                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22875                 }
22876                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22877                         NDR_PULL_ALLOC(ndr, r->out.needed);
22878                 }
22879                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
22880                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
22881                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
22882                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
22883                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
22884                         NDR_PULL_ALLOC(ndr, r->out.count);
22885                 }
22886                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
22887                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
22888                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
22889                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
22890                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
22891         }
22892         return NDR_ERR_SUCCESS;
22893 }
22894
22895 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumMonitors(struct ndr_push *ndr, int flags, const struct __spoolss_EnumMonitors *r)
22896 {
22897         uint32_t cntr_info_0;
22898         if (flags & NDR_IN) {
22899                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
22900                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
22901         }
22902         if (flags & NDR_OUT) {
22903                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22904                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22905                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22906                 }
22907                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22908                         NDR_CHECK(ndr_push_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22909                 }
22910         }
22911         return NDR_ERR_SUCCESS;
22912 }
22913
22914 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumMonitors(struct ndr_pull *ndr, int flags, struct __spoolss_EnumMonitors *r)
22915 {
22916         uint32_t cntr_info_0;
22917         TALLOC_CTX *_mem_save_info_0;
22918         if (flags & NDR_IN) {
22919                 ZERO_STRUCT(r->out);
22920
22921                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
22922                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
22923         }
22924         if (flags & NDR_OUT) {
22925                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
22926                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
22927                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
22928                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22929                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
22930                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
22931                 }
22932                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
22933                         NDR_CHECK(ndr_pull_spoolss_MonitorInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
22934                 }
22935                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
22936         }
22937         return NDR_ERR_SUCCESS;
22938 }
22939
22940 _PUBLIC_ void ndr_print_spoolss_EnumMonitors(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumMonitors *r)
22941 {
22942         uint32_t cntr_info_2;
22943         ndr_print_struct(ndr, name, "spoolss_EnumMonitors");
22944         ndr->depth++;
22945         if (flags & NDR_SET_VALUES) {
22946                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
22947         }
22948         if (flags & NDR_IN) {
22949                 ndr_print_struct(ndr, "in", "spoolss_EnumMonitors");
22950                 ndr->depth++;
22951                 ndr_print_ptr(ndr, "servername", r->in.servername);
22952                 ndr->depth++;
22953                 if (r->in.servername) {
22954                         ndr_print_string(ndr, "servername", r->in.servername);
22955                 }
22956                 ndr->depth--;
22957                 ndr_print_uint32(ndr, "level", r->in.level);
22958                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
22959                 ndr->depth++;
22960                 if (r->in.buffer) {
22961                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
22962                 }
22963                 ndr->depth--;
22964                 ndr_print_uint32(ndr, "offered", r->in.offered);
22965                 ndr->depth--;
22966         }
22967         if (flags & NDR_OUT) {
22968                 ndr_print_struct(ndr, "out", "spoolss_EnumMonitors");
22969                 ndr->depth++;
22970                 ndr_print_ptr(ndr, "count", r->out.count);
22971                 ndr->depth++;
22972                 ndr_print_uint32(ndr, "count", *r->out.count);
22973                 ndr->depth--;
22974                 ndr_print_ptr(ndr, "info", r->out.info);
22975                 ndr->depth++;
22976                 ndr_print_ptr(ndr, "info", *r->out.info);
22977                 ndr->depth++;
22978                 if (*r->out.info) {
22979                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
22980                         ndr->depth++;
22981                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
22982                                 char *idx_2=NULL;
22983                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
22984                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
22985                                         ndr_print_spoolss_MonitorInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
22986                                         free(idx_2);
22987                                 }
22988                         }
22989                         ndr->depth--;
22990                 }
22991                 ndr->depth--;
22992                 ndr->depth--;
22993                 ndr_print_ptr(ndr, "needed", r->out.needed);
22994                 ndr->depth++;
22995                 ndr_print_uint32(ndr, "needed", *r->out.needed);
22996                 ndr->depth--;
22997                 ndr_print_WERROR(ndr, "result", r->out.result);
22998                 ndr->depth--;
22999         }
23000         ndr->depth--;
23001 }
23002
23003 static enum ndr_err_code ndr_push_spoolss_AddPort(struct ndr_push *ndr, int flags, const struct spoolss_AddPort *r)
23004 {
23005         if (flags & NDR_IN) {
23006                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server_name));
23007                 if (r->in.server_name) {
23008                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23009                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
23011                         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));
23012                 }
23013                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.unknown));
23014                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23015                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23016                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.monitor_name, CH_UTF16)));
23017                 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));
23018         }
23019         if (flags & NDR_OUT) {
23020                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23021         }
23022         return NDR_ERR_SUCCESS;
23023 }
23024
23025 static enum ndr_err_code ndr_pull_spoolss_AddPort(struct ndr_pull *ndr, int flags, struct spoolss_AddPort *r)
23026 {
23027         uint32_t _ptr_server_name;
23028         TALLOC_CTX *_mem_save_server_name_0;
23029         if (flags & NDR_IN) {
23030                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server_name));
23031                 if (_ptr_server_name) {
23032                         NDR_PULL_ALLOC(ndr, r->in.server_name);
23033                 } else {
23034                         r->in.server_name = NULL;
23035                 }
23036                 if (r->in.server_name) {
23037                         _mem_save_server_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23038                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server_name, 0);
23039                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
23040                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
23041                         if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
23042                                 return 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));
23043                         }
23044                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
23045                         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));
23046                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_name_0, 0);
23047                 }
23048                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.unknown));
23049                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.monitor_name));
23050                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.monitor_name));
23051                 if (ndr_get_array_length(ndr, &r->in.monitor_name) > ndr_get_array_size(ndr, &r->in.monitor_name)) {
23052                         return 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));
23053                 }
23054                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.monitor_name), sizeof(uint16_t)));
23055                 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));
23056         }
23057         if (flags & NDR_OUT) {
23058                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23059         }
23060         return NDR_ERR_SUCCESS;
23061 }
23062
23063 _PUBLIC_ void ndr_print_spoolss_AddPort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPort *r)
23064 {
23065         ndr_print_struct(ndr, name, "spoolss_AddPort");
23066         ndr->depth++;
23067         if (flags & NDR_SET_VALUES) {
23068                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23069         }
23070         if (flags & NDR_IN) {
23071                 ndr_print_struct(ndr, "in", "spoolss_AddPort");
23072                 ndr->depth++;
23073                 ndr_print_ptr(ndr, "server_name", r->in.server_name);
23074                 ndr->depth++;
23075                 if (r->in.server_name) {
23076                         ndr_print_string(ndr, "server_name", r->in.server_name);
23077                 }
23078                 ndr->depth--;
23079                 ndr_print_uint32(ndr, "unknown", r->in.unknown);
23080                 ndr_print_string(ndr, "monitor_name", r->in.monitor_name);
23081                 ndr->depth--;
23082         }
23083         if (flags & NDR_OUT) {
23084                 ndr_print_struct(ndr, "out", "spoolss_AddPort");
23085                 ndr->depth++;
23086                 ndr_print_WERROR(ndr, "result", r->out.result);
23087                 ndr->depth--;
23088         }
23089         ndr->depth--;
23090 }
23091
23092 static enum ndr_err_code ndr_push_spoolss_ConfigurePort(struct ndr_push *ndr, int flags, const struct spoolss_ConfigurePort *r)
23093 {
23094         if (flags & NDR_IN) {
23095         }
23096         if (flags & NDR_OUT) {
23097                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23098         }
23099         return NDR_ERR_SUCCESS;
23100 }
23101
23102 static enum ndr_err_code ndr_pull_spoolss_ConfigurePort(struct ndr_pull *ndr, int flags, struct spoolss_ConfigurePort *r)
23103 {
23104         if (flags & NDR_IN) {
23105         }
23106         if (flags & NDR_OUT) {
23107                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23108         }
23109         return NDR_ERR_SUCCESS;
23110 }
23111
23112 _PUBLIC_ void ndr_print_spoolss_ConfigurePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ConfigurePort *r)
23113 {
23114         ndr_print_struct(ndr, name, "spoolss_ConfigurePort");
23115         ndr->depth++;
23116         if (flags & NDR_SET_VALUES) {
23117                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23118         }
23119         if (flags & NDR_IN) {
23120                 ndr_print_struct(ndr, "in", "spoolss_ConfigurePort");
23121                 ndr->depth++;
23122                 ndr->depth--;
23123         }
23124         if (flags & NDR_OUT) {
23125                 ndr_print_struct(ndr, "out", "spoolss_ConfigurePort");
23126                 ndr->depth++;
23127                 ndr_print_WERROR(ndr, "result", r->out.result);
23128                 ndr->depth--;
23129         }
23130         ndr->depth--;
23131 }
23132
23133 static enum ndr_err_code ndr_push_spoolss_DeletePort(struct ndr_push *ndr, int flags, const struct spoolss_DeletePort *r)
23134 {
23135         if (flags & NDR_IN) {
23136         }
23137         if (flags & NDR_OUT) {
23138                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23139         }
23140         return NDR_ERR_SUCCESS;
23141 }
23142
23143 static enum ndr_err_code ndr_pull_spoolss_DeletePort(struct ndr_pull *ndr, int flags, struct spoolss_DeletePort *r)
23144 {
23145         if (flags & NDR_IN) {
23146         }
23147         if (flags & NDR_OUT) {
23148                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23149         }
23150         return NDR_ERR_SUCCESS;
23151 }
23152
23153 _PUBLIC_ void ndr_print_spoolss_DeletePort(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePort *r)
23154 {
23155         ndr_print_struct(ndr, name, "spoolss_DeletePort");
23156         ndr->depth++;
23157         if (flags & NDR_SET_VALUES) {
23158                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23159         }
23160         if (flags & NDR_IN) {
23161                 ndr_print_struct(ndr, "in", "spoolss_DeletePort");
23162                 ndr->depth++;
23163                 ndr->depth--;
23164         }
23165         if (flags & NDR_OUT) {
23166                 ndr_print_struct(ndr, "out", "spoolss_DeletePort");
23167                 ndr->depth++;
23168                 ndr_print_WERROR(ndr, "result", r->out.result);
23169                 ndr->depth--;
23170         }
23171         ndr->depth--;
23172 }
23173
23174 static enum ndr_err_code ndr_push_spoolss_CreatePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_CreatePrinterIC *r)
23175 {
23176         if (flags & NDR_IN) {
23177         }
23178         if (flags & NDR_OUT) {
23179                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23180         }
23181         return NDR_ERR_SUCCESS;
23182 }
23183
23184 static enum ndr_err_code ndr_pull_spoolss_CreatePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_CreatePrinterIC *r)
23185 {
23186         if (flags & NDR_IN) {
23187         }
23188         if (flags & NDR_OUT) {
23189                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23190         }
23191         return NDR_ERR_SUCCESS;
23192 }
23193
23194 _PUBLIC_ void ndr_print_spoolss_CreatePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_CreatePrinterIC *r)
23195 {
23196         ndr_print_struct(ndr, name, "spoolss_CreatePrinterIC");
23197         ndr->depth++;
23198         if (flags & NDR_SET_VALUES) {
23199                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23200         }
23201         if (flags & NDR_IN) {
23202                 ndr_print_struct(ndr, "in", "spoolss_CreatePrinterIC");
23203                 ndr->depth++;
23204                 ndr->depth--;
23205         }
23206         if (flags & NDR_OUT) {
23207                 ndr_print_struct(ndr, "out", "spoolss_CreatePrinterIC");
23208                 ndr->depth++;
23209                 ndr_print_WERROR(ndr, "result", r->out.result);
23210                 ndr->depth--;
23211         }
23212         ndr->depth--;
23213 }
23214
23215 static enum ndr_err_code ndr_push_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23216 {
23217         if (flags & NDR_IN) {
23218         }
23219         if (flags & NDR_OUT) {
23220                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23221         }
23222         return NDR_ERR_SUCCESS;
23223 }
23224
23225 static enum ndr_err_code ndr_pull_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_PlayGDIScriptOnPrinterIC *r)
23226 {
23227         if (flags & NDR_IN) {
23228         }
23229         if (flags & NDR_OUT) {
23230                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23231         }
23232         return NDR_ERR_SUCCESS;
23233 }
23234
23235 _PUBLIC_ void ndr_print_spoolss_PlayGDIScriptOnPrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PlayGDIScriptOnPrinterIC *r)
23236 {
23237         ndr_print_struct(ndr, name, "spoolss_PlayGDIScriptOnPrinterIC");
23238         ndr->depth++;
23239         if (flags & NDR_SET_VALUES) {
23240                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23241         }
23242         if (flags & NDR_IN) {
23243                 ndr_print_struct(ndr, "in", "spoolss_PlayGDIScriptOnPrinterIC");
23244                 ndr->depth++;
23245                 ndr->depth--;
23246         }
23247         if (flags & NDR_OUT) {
23248                 ndr_print_struct(ndr, "out", "spoolss_PlayGDIScriptOnPrinterIC");
23249                 ndr->depth++;
23250                 ndr_print_WERROR(ndr, "result", r->out.result);
23251                 ndr->depth--;
23252         }
23253         ndr->depth--;
23254 }
23255
23256 static enum ndr_err_code ndr_push_spoolss_DeletePrinterIC(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterIC *r)
23257 {
23258         if (flags & NDR_IN) {
23259         }
23260         if (flags & NDR_OUT) {
23261                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23262         }
23263         return NDR_ERR_SUCCESS;
23264 }
23265
23266 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterIC(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterIC *r)
23267 {
23268         if (flags & NDR_IN) {
23269         }
23270         if (flags & NDR_OUT) {
23271                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23272         }
23273         return NDR_ERR_SUCCESS;
23274 }
23275
23276 _PUBLIC_ void ndr_print_spoolss_DeletePrinterIC(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterIC *r)
23277 {
23278         ndr_print_struct(ndr, name, "spoolss_DeletePrinterIC");
23279         ndr->depth++;
23280         if (flags & NDR_SET_VALUES) {
23281                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23282         }
23283         if (flags & NDR_IN) {
23284                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterIC");
23285                 ndr->depth++;
23286                 ndr->depth--;
23287         }
23288         if (flags & NDR_OUT) {
23289                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterIC");
23290                 ndr->depth++;
23291                 ndr_print_WERROR(ndr, "result", r->out.result);
23292                 ndr->depth--;
23293         }
23294         ndr->depth--;
23295 }
23296
23297 static enum ndr_err_code ndr_push_spoolss_AddPrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterConnection *r)
23298 {
23299         if (flags & NDR_IN) {
23300         }
23301         if (flags & NDR_OUT) {
23302                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23303         }
23304         return NDR_ERR_SUCCESS;
23305 }
23306
23307 static enum ndr_err_code ndr_pull_spoolss_AddPrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterConnection *r)
23308 {
23309         if (flags & NDR_IN) {
23310         }
23311         if (flags & NDR_OUT) {
23312                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23313         }
23314         return NDR_ERR_SUCCESS;
23315 }
23316
23317 _PUBLIC_ void ndr_print_spoolss_AddPrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterConnection *r)
23318 {
23319         ndr_print_struct(ndr, name, "spoolss_AddPrinterConnection");
23320         ndr->depth++;
23321         if (flags & NDR_SET_VALUES) {
23322                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23323         }
23324         if (flags & NDR_IN) {
23325                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterConnection");
23326                 ndr->depth++;
23327                 ndr->depth--;
23328         }
23329         if (flags & NDR_OUT) {
23330                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterConnection");
23331                 ndr->depth++;
23332                 ndr_print_WERROR(ndr, "result", r->out.result);
23333                 ndr->depth--;
23334         }
23335         ndr->depth--;
23336 }
23337
23338 static enum ndr_err_code ndr_push_spoolss_DeletePrinterConnection(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterConnection *r)
23339 {
23340         if (flags & NDR_IN) {
23341         }
23342         if (flags & NDR_OUT) {
23343                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23344         }
23345         return NDR_ERR_SUCCESS;
23346 }
23347
23348 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterConnection(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterConnection *r)
23349 {
23350         if (flags & NDR_IN) {
23351         }
23352         if (flags & NDR_OUT) {
23353                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23354         }
23355         return NDR_ERR_SUCCESS;
23356 }
23357
23358 _PUBLIC_ void ndr_print_spoolss_DeletePrinterConnection(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterConnection *r)
23359 {
23360         ndr_print_struct(ndr, name, "spoolss_DeletePrinterConnection");
23361         ndr->depth++;
23362         if (flags & NDR_SET_VALUES) {
23363                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23364         }
23365         if (flags & NDR_IN) {
23366                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterConnection");
23367                 ndr->depth++;
23368                 ndr->depth--;
23369         }
23370         if (flags & NDR_OUT) {
23371                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterConnection");
23372                 ndr->depth++;
23373                 ndr_print_WERROR(ndr, "result", r->out.result);
23374                 ndr->depth--;
23375         }
23376         ndr->depth--;
23377 }
23378
23379 static enum ndr_err_code ndr_push_spoolss_PrinterMessageBox(struct ndr_push *ndr, int flags, const struct spoolss_PrinterMessageBox *r)
23380 {
23381         if (flags & NDR_IN) {
23382         }
23383         if (flags & NDR_OUT) {
23384                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23385         }
23386         return NDR_ERR_SUCCESS;
23387 }
23388
23389 static enum ndr_err_code ndr_pull_spoolss_PrinterMessageBox(struct ndr_pull *ndr, int flags, struct spoolss_PrinterMessageBox *r)
23390 {
23391         if (flags & NDR_IN) {
23392         }
23393         if (flags & NDR_OUT) {
23394                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23395         }
23396         return NDR_ERR_SUCCESS;
23397 }
23398
23399 _PUBLIC_ void ndr_print_spoolss_PrinterMessageBox(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_PrinterMessageBox *r)
23400 {
23401         ndr_print_struct(ndr, name, "spoolss_PrinterMessageBox");
23402         ndr->depth++;
23403         if (flags & NDR_SET_VALUES) {
23404                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23405         }
23406         if (flags & NDR_IN) {
23407                 ndr_print_struct(ndr, "in", "spoolss_PrinterMessageBox");
23408                 ndr->depth++;
23409                 ndr->depth--;
23410         }
23411         if (flags & NDR_OUT) {
23412                 ndr_print_struct(ndr, "out", "spoolss_PrinterMessageBox");
23413                 ndr->depth++;
23414                 ndr_print_WERROR(ndr, "result", r->out.result);
23415                 ndr->depth--;
23416         }
23417         ndr->depth--;
23418 }
23419
23420 static enum ndr_err_code ndr_push_spoolss_AddMonitor(struct ndr_push *ndr, int flags, const struct spoolss_AddMonitor *r)
23421 {
23422         if (flags & NDR_IN) {
23423         }
23424         if (flags & NDR_OUT) {
23425                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23426         }
23427         return NDR_ERR_SUCCESS;
23428 }
23429
23430 static enum ndr_err_code ndr_pull_spoolss_AddMonitor(struct ndr_pull *ndr, int flags, struct spoolss_AddMonitor *r)
23431 {
23432         if (flags & NDR_IN) {
23433         }
23434         if (flags & NDR_OUT) {
23435                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23436         }
23437         return NDR_ERR_SUCCESS;
23438 }
23439
23440 _PUBLIC_ void ndr_print_spoolss_AddMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddMonitor *r)
23441 {
23442         ndr_print_struct(ndr, name, "spoolss_AddMonitor");
23443         ndr->depth++;
23444         if (flags & NDR_SET_VALUES) {
23445                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23446         }
23447         if (flags & NDR_IN) {
23448                 ndr_print_struct(ndr, "in", "spoolss_AddMonitor");
23449                 ndr->depth++;
23450                 ndr->depth--;
23451         }
23452         if (flags & NDR_OUT) {
23453                 ndr_print_struct(ndr, "out", "spoolss_AddMonitor");
23454                 ndr->depth++;
23455                 ndr_print_WERROR(ndr, "result", r->out.result);
23456                 ndr->depth--;
23457         }
23458         ndr->depth--;
23459 }
23460
23461 static enum ndr_err_code ndr_push_spoolss_DeleteMonitor(struct ndr_push *ndr, int flags, const struct spoolss_DeleteMonitor *r)
23462 {
23463         if (flags & NDR_IN) {
23464         }
23465         if (flags & NDR_OUT) {
23466                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23467         }
23468         return NDR_ERR_SUCCESS;
23469 }
23470
23471 static enum ndr_err_code ndr_pull_spoolss_DeleteMonitor(struct ndr_pull *ndr, int flags, struct spoolss_DeleteMonitor *r)
23472 {
23473         if (flags & NDR_IN) {
23474         }
23475         if (flags & NDR_OUT) {
23476                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23477         }
23478         return NDR_ERR_SUCCESS;
23479 }
23480
23481 _PUBLIC_ void ndr_print_spoolss_DeleteMonitor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeleteMonitor *r)
23482 {
23483         ndr_print_struct(ndr, name, "spoolss_DeleteMonitor");
23484         ndr->depth++;
23485         if (flags & NDR_SET_VALUES) {
23486                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23487         }
23488         if (flags & NDR_IN) {
23489                 ndr_print_struct(ndr, "in", "spoolss_DeleteMonitor");
23490                 ndr->depth++;
23491                 ndr->depth--;
23492         }
23493         if (flags & NDR_OUT) {
23494                 ndr_print_struct(ndr, "out", "spoolss_DeleteMonitor");
23495                 ndr->depth++;
23496                 ndr_print_WERROR(ndr, "result", r->out.result);
23497                 ndr->depth--;
23498         }
23499         ndr->depth--;
23500 }
23501
23502 static enum ndr_err_code ndr_push_spoolss_DeletePrintProcessor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProcessor *r)
23503 {
23504         if (flags & NDR_IN) {
23505         }
23506         if (flags & NDR_OUT) {
23507                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23508         }
23509         return NDR_ERR_SUCCESS;
23510 }
23511
23512 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProcessor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProcessor *r)
23513 {
23514         if (flags & NDR_IN) {
23515         }
23516         if (flags & NDR_OUT) {
23517                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23518         }
23519         return NDR_ERR_SUCCESS;
23520 }
23521
23522 _PUBLIC_ void ndr_print_spoolss_DeletePrintProcessor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProcessor *r)
23523 {
23524         ndr_print_struct(ndr, name, "spoolss_DeletePrintProcessor");
23525         ndr->depth++;
23526         if (flags & NDR_SET_VALUES) {
23527                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23528         }
23529         if (flags & NDR_IN) {
23530                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProcessor");
23531                 ndr->depth++;
23532                 ndr->depth--;
23533         }
23534         if (flags & NDR_OUT) {
23535                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProcessor");
23536                 ndr->depth++;
23537                 ndr_print_WERROR(ndr, "result", r->out.result);
23538                 ndr->depth--;
23539         }
23540         ndr->depth--;
23541 }
23542
23543 static enum ndr_err_code ndr_push_spoolss_AddPrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_AddPrintProvidor *r)
23544 {
23545         if (flags & NDR_IN) {
23546         }
23547         if (flags & NDR_OUT) {
23548                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23549         }
23550         return NDR_ERR_SUCCESS;
23551 }
23552
23553 static enum ndr_err_code ndr_pull_spoolss_AddPrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_AddPrintProvidor *r)
23554 {
23555         if (flags & NDR_IN) {
23556         }
23557         if (flags & NDR_OUT) {
23558                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23559         }
23560         return NDR_ERR_SUCCESS;
23561 }
23562
23563 _PUBLIC_ void ndr_print_spoolss_AddPrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrintProvidor *r)
23564 {
23565         ndr_print_struct(ndr, name, "spoolss_AddPrintProvidor");
23566         ndr->depth++;
23567         if (flags & NDR_SET_VALUES) {
23568                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23569         }
23570         if (flags & NDR_IN) {
23571                 ndr_print_struct(ndr, "in", "spoolss_AddPrintProvidor");
23572                 ndr->depth++;
23573                 ndr->depth--;
23574         }
23575         if (flags & NDR_OUT) {
23576                 ndr_print_struct(ndr, "out", "spoolss_AddPrintProvidor");
23577                 ndr->depth++;
23578                 ndr_print_WERROR(ndr, "result", r->out.result);
23579                 ndr->depth--;
23580         }
23581         ndr->depth--;
23582 }
23583
23584 static enum ndr_err_code ndr_push_spoolss_DeletePrintProvidor(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrintProvidor *r)
23585 {
23586         if (flags & NDR_IN) {
23587         }
23588         if (flags & NDR_OUT) {
23589                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23590         }
23591         return NDR_ERR_SUCCESS;
23592 }
23593
23594 static enum ndr_err_code ndr_pull_spoolss_DeletePrintProvidor(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrintProvidor *r)
23595 {
23596         if (flags & NDR_IN) {
23597         }
23598         if (flags & NDR_OUT) {
23599                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23600         }
23601         return NDR_ERR_SUCCESS;
23602 }
23603
23604 _PUBLIC_ void ndr_print_spoolss_DeletePrintProvidor(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrintProvidor *r)
23605 {
23606         ndr_print_struct(ndr, name, "spoolss_DeletePrintProvidor");
23607         ndr->depth++;
23608         if (flags & NDR_SET_VALUES) {
23609                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23610         }
23611         if (flags & NDR_IN) {
23612                 ndr_print_struct(ndr, "in", "spoolss_DeletePrintProvidor");
23613                 ndr->depth++;
23614                 ndr->depth--;
23615         }
23616         if (flags & NDR_OUT) {
23617                 ndr_print_struct(ndr, "out", "spoolss_DeletePrintProvidor");
23618                 ndr->depth++;
23619                 ndr_print_WERROR(ndr, "result", r->out.result);
23620                 ndr->depth--;
23621         }
23622         ndr->depth--;
23623 }
23624
23625 _PUBLIC_ enum ndr_err_code ndr_push__spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct _spoolss_EnumPrintProcDataTypes *r)
23626 {
23627         if (flags & NDR_IN) {
23628                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
23629                 if (r->in.servername) {
23630                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23631                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23632                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
23633                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
23634                 }
23635                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.print_processor_name));
23636                 if (r->in.print_processor_name) {
23637                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23638                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23639                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.print_processor_name, CH_UTF16)));
23640                         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));
23641                 }
23642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23643                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
23644                 if (r->in.buffer) {
23645                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
23646                 }
23647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
23648         }
23649         if (flags & NDR_OUT) {
23650                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
23651                 if (r->out.info) {
23652                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->out.info));
23653                 }
23654                 if (r->out.needed == NULL) {
23655                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23656                 }
23657                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
23658                 if (r->out.count == NULL) {
23659                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23660                 }
23661                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
23662                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23663         }
23664         return NDR_ERR_SUCCESS;
23665 }
23666
23667 _PUBLIC_ enum ndr_err_code ndr_pull__spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct _spoolss_EnumPrintProcDataTypes *r)
23668 {
23669         uint32_t _ptr_servername;
23670         uint32_t _ptr_print_processor_name;
23671         uint32_t _ptr_buffer;
23672         uint32_t _ptr_info;
23673         TALLOC_CTX *_mem_save_servername_0;
23674         TALLOC_CTX *_mem_save_print_processor_name_0;
23675         TALLOC_CTX *_mem_save_buffer_0;
23676         TALLOC_CTX *_mem_save_info_0;
23677         TALLOC_CTX *_mem_save_needed_0;
23678         TALLOC_CTX *_mem_save_count_0;
23679         if (flags & NDR_IN) {
23680                 ZERO_STRUCT(r->out);
23681
23682                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
23683                 if (_ptr_servername) {
23684                         NDR_PULL_ALLOC(ndr, r->in.servername);
23685                 } else {
23686                         r->in.servername = NULL;
23687                 }
23688                 if (r->in.servername) {
23689                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
23690                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
23691                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
23692                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
23693                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
23694                                 return 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));
23695                         }
23696                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
23697                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
23698                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
23699                 }
23700                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_print_processor_name));
23701                 if (_ptr_print_processor_name) {
23702                         NDR_PULL_ALLOC(ndr, r->in.print_processor_name);
23703                 } else {
23704                         r->in.print_processor_name = NULL;
23705                 }
23706                 if (r->in.print_processor_name) {
23707                         _mem_save_print_processor_name_0 = NDR_PULL_GET_MEM_CTX(ndr);
23708                         NDR_PULL_SET_MEM_CTX(ndr, r->in.print_processor_name, 0);
23709                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.print_processor_name));
23710                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.print_processor_name));
23711                         if (ndr_get_array_length(ndr, &r->in.print_processor_name) > ndr_get_array_size(ndr, &r->in.print_processor_name)) {
23712                                 return 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));
23713                         }
23714                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.print_processor_name), sizeof(uint16_t)));
23715                         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));
23716                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_print_processor_name_0, 0);
23717                 }
23718                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23719                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
23720                 if (_ptr_buffer) {
23721                         NDR_PULL_ALLOC(ndr, r->in.buffer);
23722                 } else {
23723                         r->in.buffer = NULL;
23724                 }
23725                 if (r->in.buffer) {
23726                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
23727                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
23728                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
23729                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
23730                 }
23731                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
23732                 NDR_PULL_ALLOC(ndr, r->out.needed);
23733                 ZERO_STRUCTP(r->out.needed);
23734                 NDR_PULL_ALLOC(ndr, r->out.count);
23735                 ZERO_STRUCTP(r->out.count);
23736         }
23737         if (flags & NDR_OUT) {
23738                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
23739                 if (_ptr_info) {
23740                         NDR_PULL_ALLOC(ndr, r->out.info);
23741                 } else {
23742                         r->out.info = NULL;
23743                 }
23744                 if (r->out.info) {
23745                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23746                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23747                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->out.info));
23748                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23749                 }
23750                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23751                         NDR_PULL_ALLOC(ndr, r->out.needed);
23752                 }
23753                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
23754                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
23755                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
23756                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
23757                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23758                         NDR_PULL_ALLOC(ndr, r->out.count);
23759                 }
23760                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
23761                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
23762                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
23763                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
23764                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23765         }
23766         return NDR_ERR_SUCCESS;
23767 }
23768
23769 _PUBLIC_ enum ndr_err_code ndr_push___spoolss_EnumPrintProcDataTypes(struct ndr_push *ndr, int flags, const struct __spoolss_EnumPrintProcDataTypes *r)
23770 {
23771         uint32_t cntr_info_0;
23772         if (flags & NDR_IN) {
23773                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
23774                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.count));
23775         }
23776         if (flags & NDR_OUT) {
23777                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23778                         NDR_CHECK(ndr_push_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23779                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23780                 }
23781                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23782                         NDR_CHECK(ndr_push_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23783                 }
23784         }
23785         return NDR_ERR_SUCCESS;
23786 }
23787
23788 _PUBLIC_ enum ndr_err_code ndr_pull___spoolss_EnumPrintProcDataTypes(struct ndr_pull *ndr, int flags, struct __spoolss_EnumPrintProcDataTypes *r)
23789 {
23790         uint32_t cntr_info_0;
23791         TALLOC_CTX *_mem_save_info_0;
23792         if (flags & NDR_IN) {
23793                 ZERO_STRUCT(r->out);
23794
23795                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
23796                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.count));
23797         }
23798         if (flags & NDR_OUT) {
23799                 NDR_PULL_ALLOC_N(ndr, r->out.info, r->in.count);
23800                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
23801                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
23802                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23803                         NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
23804                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
23805                 }
23806                 for (cntr_info_0 = 0; cntr_info_0 < r->in.count; cntr_info_0++) {
23807                         NDR_CHECK(ndr_pull_spoolss_PrintProcDataTypesInfo(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
23808                 }
23809                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
23810         }
23811         return NDR_ERR_SUCCESS;
23812 }
23813
23814 _PUBLIC_ void ndr_print_spoolss_EnumPrintProcDataTypes(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrintProcDataTypes *r)
23815 {
23816         uint32_t cntr_info_2;
23817         ndr_print_struct(ndr, name, "spoolss_EnumPrintProcDataTypes");
23818         ndr->depth++;
23819         if (flags & NDR_SET_VALUES) {
23820                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23821         }
23822         if (flags & NDR_IN) {
23823                 ndr_print_struct(ndr, "in", "spoolss_EnumPrintProcDataTypes");
23824                 ndr->depth++;
23825                 ndr_print_ptr(ndr, "servername", r->in.servername);
23826                 ndr->depth++;
23827                 if (r->in.servername) {
23828                         ndr_print_string(ndr, "servername", r->in.servername);
23829                 }
23830                 ndr->depth--;
23831                 ndr_print_ptr(ndr, "print_processor_name", r->in.print_processor_name);
23832                 ndr->depth++;
23833                 if (r->in.print_processor_name) {
23834                         ndr_print_string(ndr, "print_processor_name", r->in.print_processor_name);
23835                 }
23836                 ndr->depth--;
23837                 ndr_print_uint32(ndr, "level", r->in.level);
23838                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
23839                 ndr->depth++;
23840                 if (r->in.buffer) {
23841                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
23842                 }
23843                 ndr->depth--;
23844                 ndr_print_uint32(ndr, "offered", r->in.offered);
23845                 ndr->depth--;
23846         }
23847         if (flags & NDR_OUT) {
23848                 ndr_print_struct(ndr, "out", "spoolss_EnumPrintProcDataTypes");
23849                 ndr->depth++;
23850                 ndr_print_ptr(ndr, "count", r->out.count);
23851                 ndr->depth++;
23852                 ndr_print_uint32(ndr, "count", *r->out.count);
23853                 ndr->depth--;
23854                 ndr_print_ptr(ndr, "info", r->out.info);
23855                 ndr->depth++;
23856                 ndr_print_ptr(ndr, "info", *r->out.info);
23857                 ndr->depth++;
23858                 if (*r->out.info) {
23859                         ndr->print(ndr, "%s: ARRAY(%d)", "info", (int)*r->out.count);
23860                         ndr->depth++;
23861                         for (cntr_info_2=0;cntr_info_2<*r->out.count;cntr_info_2++) {
23862                                 char *idx_2=NULL;
23863                                 if (asprintf(&idx_2, "[%d]", cntr_info_2) != -1) {
23864                                         ndr_print_set_switch_value(ndr, &(*r->out.info)[cntr_info_2], r->in.level);
23865                                         ndr_print_spoolss_PrintProcDataTypesInfo(ndr, "info", &(*r->out.info)[cntr_info_2]);
23866                                         free(idx_2);
23867                                 }
23868                         }
23869                         ndr->depth--;
23870                 }
23871                 ndr->depth--;
23872                 ndr->depth--;
23873                 ndr_print_ptr(ndr, "needed", r->out.needed);
23874                 ndr->depth++;
23875                 ndr_print_uint32(ndr, "needed", *r->out.needed);
23876                 ndr->depth--;
23877                 ndr_print_WERROR(ndr, "result", r->out.result);
23878                 ndr->depth--;
23879         }
23880         ndr->depth--;
23881 }
23882
23883 static enum ndr_err_code ndr_push_spoolss_ResetPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinter *r)
23884 {
23885         if (flags & NDR_IN) {
23886                 if (r->in.handle == NULL) {
23887                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23888                 }
23889                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23890                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.data_type));
23891                 if (r->in.data_type) {
23892                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23893                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
23894                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.data_type, CH_UTF16)));
23895                         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));
23896                 }
23897                 if (r->in.devmode_ctr == NULL) {
23898                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23899                 }
23900                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23901         }
23902         if (flags & NDR_OUT) {
23903                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
23904         }
23905         return NDR_ERR_SUCCESS;
23906 }
23907
23908 static enum ndr_err_code ndr_pull_spoolss_ResetPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinter *r)
23909 {
23910         uint32_t _ptr_data_type;
23911         TALLOC_CTX *_mem_save_handle_0;
23912         TALLOC_CTX *_mem_save_data_type_0;
23913         TALLOC_CTX *_mem_save_devmode_ctr_0;
23914         if (flags & NDR_IN) {
23915                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23916                         NDR_PULL_ALLOC(ndr, r->in.handle);
23917                 }
23918                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
23919                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
23920                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23921                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
23922                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_data_type));
23923                 if (_ptr_data_type) {
23924                         NDR_PULL_ALLOC(ndr, r->in.data_type);
23925                 } else {
23926                         r->in.data_type = NULL;
23927                 }
23928                 if (r->in.data_type) {
23929                         _mem_save_data_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
23930                         NDR_PULL_SET_MEM_CTX(ndr, r->in.data_type, 0);
23931                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.data_type));
23932                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.data_type));
23933                         if (ndr_get_array_length(ndr, &r->in.data_type) > ndr_get_array_size(ndr, &r->in.data_type)) {
23934                                 return 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));
23935                         }
23936                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.data_type), sizeof(uint16_t)));
23937                         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));
23938                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_type_0, 0);
23939                 }
23940                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
23941                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
23942                 }
23943                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
23944                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
23945                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
23946                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
23947         }
23948         if (flags & NDR_OUT) {
23949                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
23950         }
23951         return NDR_ERR_SUCCESS;
23952 }
23953
23954 _PUBLIC_ void ndr_print_spoolss_ResetPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinter *r)
23955 {
23956         ndr_print_struct(ndr, name, "spoolss_ResetPrinter");
23957         ndr->depth++;
23958         if (flags & NDR_SET_VALUES) {
23959                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
23960         }
23961         if (flags & NDR_IN) {
23962                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinter");
23963                 ndr->depth++;
23964                 ndr_print_ptr(ndr, "handle", r->in.handle);
23965                 ndr->depth++;
23966                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
23967                 ndr->depth--;
23968                 ndr_print_ptr(ndr, "data_type", r->in.data_type);
23969                 ndr->depth++;
23970                 if (r->in.data_type) {
23971                         ndr_print_string(ndr, "data_type", r->in.data_type);
23972                 }
23973                 ndr->depth--;
23974                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
23975                 ndr->depth++;
23976                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
23977                 ndr->depth--;
23978                 ndr->depth--;
23979         }
23980         if (flags & NDR_OUT) {
23981                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinter");
23982                 ndr->depth++;
23983                 ndr_print_WERROR(ndr, "result", r->out.result);
23984                 ndr->depth--;
23985         }
23986         ndr->depth--;
23987 }
23988
23989 static enum ndr_err_code ndr_push_spoolss_GetPrinterDriver2(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDriver2 *r)
23990 {
23991         if (flags & NDR_IN) {
23992                 if (r->in.handle == NULL) {
23993                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
23994                 }
23995                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
23996                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.architecture));
23997                 if (r->in.architecture) {
23998                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
23999                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24000                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
24001                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
24002                 }
24003                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
24004                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24005                 if (r->in.buffer) {
24006                         NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, *r->in.buffer));
24007                 }
24008                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
24009                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_major_version));
24010                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.client_minor_version));
24011         }
24012         if (flags & NDR_OUT) {
24013                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->out.info));
24014                 if (r->out.info) {
24015                         {
24016                                 struct ndr_push *_ndr_info;
24017                                 NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24018                                 NDR_CHECK(ndr_push_set_switch_value(_ndr_info, r->out.info, r->in.level));
24019                                 NDR_CHECK(ndr_push_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24020                                 NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24021                         }
24022                 }
24023                 if (r->out.needed == NULL) {
24024                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24025                 }
24026                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
24027                 if (r->out.server_major_version == NULL) {
24028                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24029                 }
24030                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_major_version));
24031                 if (r->out.server_minor_version == NULL) {
24032                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24033                 }
24034                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.server_minor_version));
24035                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24036         }
24037         return NDR_ERR_SUCCESS;
24038 }
24039
24040 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDriver2(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDriver2 *r)
24041 {
24042         uint32_t _ptr_architecture;
24043         uint32_t _ptr_buffer;
24044         uint32_t _ptr_info;
24045         TALLOC_CTX *_mem_save_handle_0;
24046         TALLOC_CTX *_mem_save_architecture_0;
24047         TALLOC_CTX *_mem_save_buffer_0;
24048         TALLOC_CTX *_mem_save_info_0;
24049         TALLOC_CTX *_mem_save_needed_0;
24050         TALLOC_CTX *_mem_save_server_major_version_0;
24051         TALLOC_CTX *_mem_save_server_minor_version_0;
24052         if (flags & NDR_IN) {
24053                 ZERO_STRUCT(r->out);
24054
24055                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24056                         NDR_PULL_ALLOC(ndr, r->in.handle);
24057                 }
24058                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24059                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24060                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24061                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24062                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_architecture));
24063                 if (_ptr_architecture) {
24064                         NDR_PULL_ALLOC(ndr, r->in.architecture);
24065                 } else {
24066                         r->in.architecture = NULL;
24067                 }
24068                 if (r->in.architecture) {
24069                         _mem_save_architecture_0 = NDR_PULL_GET_MEM_CTX(ndr);
24070                         NDR_PULL_SET_MEM_CTX(ndr, r->in.architecture, 0);
24071                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
24072                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
24073                         if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
24074                                 return 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));
24075                         }
24076                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
24077                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
24078                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_architecture_0, 0);
24079                 }
24080                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
24081                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24082                 if (_ptr_buffer) {
24083                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24084                 } else {
24085                         r->in.buffer = NULL;
24086                 }
24087                 if (r->in.buffer) {
24088                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24089                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24090                         NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, r->in.buffer));
24091                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24092                 }
24093                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
24094                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_major_version));
24095                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.client_minor_version));
24096                 NDR_PULL_ALLOC(ndr, r->out.needed);
24097                 ZERO_STRUCTP(r->out.needed);
24098                 NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24099                 ZERO_STRUCTP(r->out.server_major_version);
24100                 NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24101                 ZERO_STRUCTP(r->out.server_minor_version);
24102         }
24103         if (flags & NDR_OUT) {
24104                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
24105                 if (_ptr_info) {
24106                         NDR_PULL_ALLOC(ndr, r->out.info);
24107                 } else {
24108                         r->out.info = NULL;
24109                 }
24110                 if (r->out.info) {
24111                         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
24112                         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
24113                         {
24114                                 struct ndr_pull *_ndr_info;
24115                                 NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_info, 4, r->in.offered));
24116                                 NDR_CHECK(ndr_pull_set_switch_value(_ndr_info, r->out.info, r->in.level));
24117                                 NDR_CHECK(ndr_pull_spoolss_DriverInfo(_ndr_info, NDR_SCALARS|NDR_BUFFERS, r->out.info));
24118                                 NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_info, 4, r->in.offered));
24119                         }
24120                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
24121                 }
24122                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24123                         NDR_PULL_ALLOC(ndr, r->out.needed);
24124                 }
24125                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
24126                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
24127                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
24128                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
24129                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24130                         NDR_PULL_ALLOC(ndr, r->out.server_major_version);
24131                 }
24132                 _mem_save_server_major_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24133                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_major_version, LIBNDR_FLAG_REF_ALLOC);
24134                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_major_version));
24135                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_major_version_0, LIBNDR_FLAG_REF_ALLOC);
24136                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24137                         NDR_PULL_ALLOC(ndr, r->out.server_minor_version);
24138                 }
24139                 _mem_save_server_minor_version_0 = NDR_PULL_GET_MEM_CTX(ndr);
24140                 NDR_PULL_SET_MEM_CTX(ndr, r->out.server_minor_version, LIBNDR_FLAG_REF_ALLOC);
24141                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.server_minor_version));
24142                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_minor_version_0, LIBNDR_FLAG_REF_ALLOC);
24143                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24144         }
24145         return NDR_ERR_SUCCESS;
24146 }
24147
24148 _PUBLIC_ void ndr_print_spoolss_GetPrinterDriver2(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDriver2 *r)
24149 {
24150         ndr_print_struct(ndr, name, "spoolss_GetPrinterDriver2");
24151         ndr->depth++;
24152         if (flags & NDR_SET_VALUES) {
24153                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24154         }
24155         if (flags & NDR_IN) {
24156                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDriver2");
24157                 ndr->depth++;
24158                 ndr_print_ptr(ndr, "handle", r->in.handle);
24159                 ndr->depth++;
24160                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24161                 ndr->depth--;
24162                 ndr_print_ptr(ndr, "architecture", r->in.architecture);
24163                 ndr->depth++;
24164                 if (r->in.architecture) {
24165                         ndr_print_string(ndr, "architecture", r->in.architecture);
24166                 }
24167                 ndr->depth--;
24168                 ndr_print_uint32(ndr, "level", r->in.level);
24169                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24170                 ndr->depth++;
24171                 if (r->in.buffer) {
24172                         ndr_print_DATA_BLOB(ndr, "buffer", *r->in.buffer);
24173                 }
24174                 ndr->depth--;
24175                 ndr_print_uint32(ndr, "offered", r->in.offered);
24176                 ndr_print_uint32(ndr, "client_major_version", r->in.client_major_version);
24177                 ndr_print_uint32(ndr, "client_minor_version", r->in.client_minor_version);
24178                 ndr->depth--;
24179         }
24180         if (flags & NDR_OUT) {
24181                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDriver2");
24182                 ndr->depth++;
24183                 ndr_print_ptr(ndr, "info", r->out.info);
24184                 ndr->depth++;
24185                 if (r->out.info) {
24186                         ndr_print_set_switch_value(ndr, r->out.info, r->in.level);
24187                         ndr_print_spoolss_DriverInfo(ndr, "info", r->out.info);
24188                 }
24189                 ndr->depth--;
24190                 ndr_print_ptr(ndr, "needed", r->out.needed);
24191                 ndr->depth++;
24192                 ndr_print_uint32(ndr, "needed", *r->out.needed);
24193                 ndr->depth--;
24194                 ndr_print_ptr(ndr, "server_major_version", r->out.server_major_version);
24195                 ndr->depth++;
24196                 ndr_print_uint32(ndr, "server_major_version", *r->out.server_major_version);
24197                 ndr->depth--;
24198                 ndr_print_ptr(ndr, "server_minor_version", r->out.server_minor_version);
24199                 ndr->depth++;
24200                 ndr_print_uint32(ndr, "server_minor_version", *r->out.server_minor_version);
24201                 ndr->depth--;
24202                 ndr_print_WERROR(ndr, "result", r->out.result);
24203                 ndr->depth--;
24204         }
24205         ndr->depth--;
24206 }
24207
24208 static enum ndr_err_code ndr_push_spoolss_FindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24209 {
24210         if (flags & NDR_IN) {
24211         }
24212         if (flags & NDR_OUT) {
24213                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24214         }
24215         return NDR_ERR_SUCCESS;
24216 }
24217
24218 static enum ndr_err_code ndr_pull_spoolss_FindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindFirstPrinterChangeNotification *r)
24219 {
24220         if (flags & NDR_IN) {
24221         }
24222         if (flags & NDR_OUT) {
24223                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24224         }
24225         return NDR_ERR_SUCCESS;
24226 }
24227
24228 _PUBLIC_ void ndr_print_spoolss_FindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindFirstPrinterChangeNotification *r)
24229 {
24230         ndr_print_struct(ndr, name, "spoolss_FindFirstPrinterChangeNotification");
24231         ndr->depth++;
24232         if (flags & NDR_SET_VALUES) {
24233                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24234         }
24235         if (flags & NDR_IN) {
24236                 ndr_print_struct(ndr, "in", "spoolss_FindFirstPrinterChangeNotification");
24237                 ndr->depth++;
24238                 ndr->depth--;
24239         }
24240         if (flags & NDR_OUT) {
24241                 ndr_print_struct(ndr, "out", "spoolss_FindFirstPrinterChangeNotification");
24242                 ndr->depth++;
24243                 ndr_print_WERROR(ndr, "result", r->out.result);
24244                 ndr->depth--;
24245         }
24246         ndr->depth--;
24247 }
24248
24249 static enum ndr_err_code ndr_push_spoolss_FindNextPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24250 {
24251         if (flags & NDR_IN) {
24252         }
24253         if (flags & NDR_OUT) {
24254                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24255         }
24256         return NDR_ERR_SUCCESS;
24257 }
24258
24259 static enum ndr_err_code ndr_pull_spoolss_FindNextPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_FindNextPrinterChangeNotification *r)
24260 {
24261         if (flags & NDR_IN) {
24262         }
24263         if (flags & NDR_OUT) {
24264                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24265         }
24266         return NDR_ERR_SUCCESS;
24267 }
24268
24269 _PUBLIC_ void ndr_print_spoolss_FindNextPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindNextPrinterChangeNotification *r)
24270 {
24271         ndr_print_struct(ndr, name, "spoolss_FindNextPrinterChangeNotification");
24272         ndr->depth++;
24273         if (flags & NDR_SET_VALUES) {
24274                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24275         }
24276         if (flags & NDR_IN) {
24277                 ndr_print_struct(ndr, "in", "spoolss_FindNextPrinterChangeNotification");
24278                 ndr->depth++;
24279                 ndr->depth--;
24280         }
24281         if (flags & NDR_OUT) {
24282                 ndr_print_struct(ndr, "out", "spoolss_FindNextPrinterChangeNotification");
24283                 ndr->depth++;
24284                 ndr_print_WERROR(ndr, "result", r->out.result);
24285                 ndr->depth--;
24286         }
24287         ndr->depth--;
24288 }
24289
24290 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_FindClosePrinterNotify(struct ndr_push *ndr, int flags, const struct spoolss_FindClosePrinterNotify *r)
24291 {
24292         if (flags & NDR_IN) {
24293                 if (r->in.handle == NULL) {
24294                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24295                 }
24296                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24297         }
24298         if (flags & NDR_OUT) {
24299                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24300         }
24301         return NDR_ERR_SUCCESS;
24302 }
24303
24304 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_FindClosePrinterNotify(struct ndr_pull *ndr, int flags, struct spoolss_FindClosePrinterNotify *r)
24305 {
24306         TALLOC_CTX *_mem_save_handle_0;
24307         if (flags & NDR_IN) {
24308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24309                         NDR_PULL_ALLOC(ndr, r->in.handle);
24310                 }
24311                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24312                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24313                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24315         }
24316         if (flags & NDR_OUT) {
24317                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24318         }
24319         return NDR_ERR_SUCCESS;
24320 }
24321
24322 _PUBLIC_ void ndr_print_spoolss_FindClosePrinterNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_FindClosePrinterNotify *r)
24323 {
24324         ndr_print_struct(ndr, name, "spoolss_FindClosePrinterNotify");
24325         ndr->depth++;
24326         if (flags & NDR_SET_VALUES) {
24327                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24328         }
24329         if (flags & NDR_IN) {
24330                 ndr_print_struct(ndr, "in", "spoolss_FindClosePrinterNotify");
24331                 ndr->depth++;
24332                 ndr_print_ptr(ndr, "handle", r->in.handle);
24333                 ndr->depth++;
24334                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24335                 ndr->depth--;
24336                 ndr->depth--;
24337         }
24338         if (flags & NDR_OUT) {
24339                 ndr_print_struct(ndr, "out", "spoolss_FindClosePrinterNotify");
24340                 ndr->depth++;
24341                 ndr_print_WERROR(ndr, "result", r->out.result);
24342                 ndr->depth--;
24343         }
24344         ndr->depth--;
24345 }
24346
24347 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24348 {
24349         if (flags & NDR_IN) {
24350         }
24351         if (flags & NDR_OUT) {
24352                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24353         }
24354         return NDR_ERR_SUCCESS;
24355 }
24356
24357 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24358 {
24359         if (flags & NDR_IN) {
24360         }
24361         if (flags & NDR_OUT) {
24362                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24363         }
24364         return NDR_ERR_SUCCESS;
24365 }
24366
24367 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotificationOld *r)
24368 {
24369         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24370         ndr->depth++;
24371         if (flags & NDR_SET_VALUES) {
24372                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24373         }
24374         if (flags & NDR_IN) {
24375                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24376                 ndr->depth++;
24377                 ndr->depth--;
24378         }
24379         if (flags & NDR_OUT) {
24380                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotificationOld");
24381                 ndr->depth++;
24382                 ndr_print_WERROR(ndr, "result", r->out.result);
24383                 ndr->depth--;
24384         }
24385         ndr->depth--;
24386 }
24387
24388 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyOpenPrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyOpenPrinter *r)
24389 {
24390         if (flags & NDR_IN) {
24391                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24392                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24393                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server_name, CH_UTF16)));
24394                 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));
24395                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24396                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
24397                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24398                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24399                 if (r->in.buffer) {
24400                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24401                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24402                 }
24403         }
24404         if (flags & NDR_OUT) {
24405                 if (r->out.handle == NULL) {
24406                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24407                 }
24408                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24409                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24410         }
24411         return NDR_ERR_SUCCESS;
24412 }
24413
24414 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyOpenPrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyOpenPrinter *r)
24415 {
24416         uint32_t _ptr_buffer;
24417         TALLOC_CTX *_mem_save_buffer_0;
24418         TALLOC_CTX *_mem_save_handle_0;
24419         if (flags & NDR_IN) {
24420                 ZERO_STRUCT(r->out);
24421
24422                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server_name));
24423                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server_name));
24424                 if (ndr_get_array_length(ndr, &r->in.server_name) > ndr_get_array_size(ndr, &r->in.server_name)) {
24425                         return 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));
24426                 }
24427                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server_name), sizeof(uint16_t)));
24428                 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));
24429                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24430                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
24431                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24432                 if (r->in.bufsize > 512) {
24433                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24434                 }
24435                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24436                 if (_ptr_buffer) {
24437                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24438                 } else {
24439                         r->in.buffer = NULL;
24440                 }
24441                 if (r->in.buffer) {
24442                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24443                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24444                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24445                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24446                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24447                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24448                 }
24449                 NDR_PULL_ALLOC(ndr, r->out.handle);
24450                 ZERO_STRUCTP(r->out.handle);
24451                 if (r->in.buffer) {
24452                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24453                 }
24454         }
24455         if (flags & NDR_OUT) {
24456                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24457                         NDR_PULL_ALLOC(ndr, r->out.handle);
24458                 }
24459                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24460                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24461                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24462                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24463                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24464         }
24465         return NDR_ERR_SUCCESS;
24466 }
24467
24468 _PUBLIC_ void ndr_print_spoolss_ReplyOpenPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyOpenPrinter *r)
24469 {
24470         ndr_print_struct(ndr, name, "spoolss_ReplyOpenPrinter");
24471         ndr->depth++;
24472         if (flags & NDR_SET_VALUES) {
24473                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24474         }
24475         if (flags & NDR_IN) {
24476                 ndr_print_struct(ndr, "in", "spoolss_ReplyOpenPrinter");
24477                 ndr->depth++;
24478                 ndr_print_string(ndr, "server_name", r->in.server_name);
24479                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24480                 ndr_print_winreg_Type(ndr, "type", r->in.type);
24481                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24482                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24483                 ndr->depth++;
24484                 if (r->in.buffer) {
24485                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24486                 }
24487                 ndr->depth--;
24488                 ndr->depth--;
24489         }
24490         if (flags & NDR_OUT) {
24491                 ndr_print_struct(ndr, "out", "spoolss_ReplyOpenPrinter");
24492                 ndr->depth++;
24493                 ndr_print_ptr(ndr, "handle", r->out.handle);
24494                 ndr->depth++;
24495                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24496                 ndr->depth--;
24497                 ndr_print_WERROR(ndr, "result", r->out.result);
24498                 ndr->depth--;
24499         }
24500         ndr->depth--;
24501 }
24502
24503 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinter(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinter *r)
24504 {
24505         if (flags & NDR_IN) {
24506                 if (r->in.handle == NULL) {
24507                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24508                 }
24509                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24510                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24511                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24512                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.buffer));
24513                 if (r->in.buffer) {
24514                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.bufsize));
24515                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.bufsize));
24516                 }
24517         }
24518         if (flags & NDR_OUT) {
24519                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24520         }
24521         return NDR_ERR_SUCCESS;
24522 }
24523
24524 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinter(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinter *r)
24525 {
24526         uint32_t _ptr_buffer;
24527         TALLOC_CTX *_mem_save_handle_0;
24528         TALLOC_CTX *_mem_save_buffer_0;
24529         if (flags & NDR_IN) {
24530                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24531                         NDR_PULL_ALLOC(ndr, r->in.handle);
24532                 }
24533                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24534                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24535                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24536                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24537                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24538                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.bufsize));
24539                 if (r->in.bufsize > 512) {
24540                         return ndr_pull_error(ndr, NDR_ERR_RANGE, "value out of range");
24541                 }
24542                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_buffer));
24543                 if (_ptr_buffer) {
24544                         NDR_PULL_ALLOC(ndr, r->in.buffer);
24545                 } else {
24546                         r->in.buffer = NULL;
24547                 }
24548                 if (r->in.buffer) {
24549                         _mem_save_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
24550                         NDR_PULL_SET_MEM_CTX(ndr, r->in.buffer, 0);
24551                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
24552                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
24553                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
24554                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_buffer_0, 0);
24555                 }
24556                 if (r->in.buffer) {
24557                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.bufsize));
24558                 }
24559         }
24560         if (flags & NDR_OUT) {
24561                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24562         }
24563         return NDR_ERR_SUCCESS;
24564 }
24565
24566 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinter *r)
24567 {
24568         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinter");
24569         ndr->depth++;
24570         if (flags & NDR_SET_VALUES) {
24571                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24572         }
24573         if (flags & NDR_IN) {
24574                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinter");
24575                 ndr->depth++;
24576                 ndr_print_ptr(ndr, "handle", r->in.handle);
24577                 ndr->depth++;
24578                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24579                 ndr->depth--;
24580                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24581                 ndr_print_uint32(ndr, "bufsize", r->in.bufsize);
24582                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
24583                 ndr->depth++;
24584                 if (r->in.buffer) {
24585                         ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.bufsize);
24586                 }
24587                 ndr->depth--;
24588                 ndr->depth--;
24589         }
24590         if (flags & NDR_OUT) {
24591                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinter");
24592                 ndr->depth++;
24593                 ndr_print_WERROR(ndr, "result", r->out.result);
24594                 ndr->depth--;
24595         }
24596         ndr->depth--;
24597 }
24598
24599 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_ReplyClosePrinter(struct ndr_push *ndr, int flags, const struct spoolss_ReplyClosePrinter *r)
24600 {
24601         if (flags & NDR_IN) {
24602                 if (r->in.handle == NULL) {
24603                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24604                 }
24605                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24606         }
24607         if (flags & NDR_OUT) {
24608                 if (r->out.handle == NULL) {
24609                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24610                 }
24611                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24612                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24613         }
24614         return NDR_ERR_SUCCESS;
24615 }
24616
24617 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_ReplyClosePrinter(struct ndr_pull *ndr, int flags, struct spoolss_ReplyClosePrinter *r)
24618 {
24619         TALLOC_CTX *_mem_save_handle_0;
24620         if (flags & NDR_IN) {
24621                 ZERO_STRUCT(r->out);
24622
24623                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24624                         NDR_PULL_ALLOC(ndr, r->in.handle);
24625                 }
24626                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24627                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24628                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24629                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24630                 NDR_PULL_ALLOC(ndr, r->out.handle);
24631                 *r->out.handle = *r->in.handle;
24632         }
24633         if (flags & NDR_OUT) {
24634                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24635                         NDR_PULL_ALLOC(ndr, r->out.handle);
24636                 }
24637                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24638                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
24639                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
24640                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24641                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24642         }
24643         return NDR_ERR_SUCCESS;
24644 }
24645
24646 _PUBLIC_ void ndr_print_spoolss_ReplyClosePrinter(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ReplyClosePrinter *r)
24647 {
24648         ndr_print_struct(ndr, name, "spoolss_ReplyClosePrinter");
24649         ndr->depth++;
24650         if (flags & NDR_SET_VALUES) {
24651                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24652         }
24653         if (flags & NDR_IN) {
24654                 ndr_print_struct(ndr, "in", "spoolss_ReplyClosePrinter");
24655                 ndr->depth++;
24656                 ndr_print_ptr(ndr, "handle", r->in.handle);
24657                 ndr->depth++;
24658                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24659                 ndr->depth--;
24660                 ndr->depth--;
24661         }
24662         if (flags & NDR_OUT) {
24663                 ndr_print_struct(ndr, "out", "spoolss_ReplyClosePrinter");
24664                 ndr->depth++;
24665                 ndr_print_ptr(ndr, "handle", r->out.handle);
24666                 ndr->depth++;
24667                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
24668                 ndr->depth--;
24669                 ndr_print_WERROR(ndr, "result", r->out.result);
24670                 ndr->depth--;
24671         }
24672         ndr->depth--;
24673 }
24674
24675 static enum ndr_err_code ndr_push_spoolss_AddPortEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPortEx *r)
24676 {
24677         if (flags & NDR_IN) {
24678         }
24679         if (flags & NDR_OUT) {
24680                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24681         }
24682         return NDR_ERR_SUCCESS;
24683 }
24684
24685 static enum ndr_err_code ndr_pull_spoolss_AddPortEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPortEx *r)
24686 {
24687         if (flags & NDR_IN) {
24688         }
24689         if (flags & NDR_OUT) {
24690                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24691         }
24692         return NDR_ERR_SUCCESS;
24693 }
24694
24695 _PUBLIC_ void ndr_print_spoolss_AddPortEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPortEx *r)
24696 {
24697         ndr_print_struct(ndr, name, "spoolss_AddPortEx");
24698         ndr->depth++;
24699         if (flags & NDR_SET_VALUES) {
24700                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24701         }
24702         if (flags & NDR_IN) {
24703                 ndr_print_struct(ndr, "in", "spoolss_AddPortEx");
24704                 ndr->depth++;
24705                 ndr->depth--;
24706         }
24707         if (flags & NDR_OUT) {
24708                 ndr_print_struct(ndr, "out", "spoolss_AddPortEx");
24709                 ndr->depth++;
24710                 ndr_print_WERROR(ndr, "result", r->out.result);
24711                 ndr->depth--;
24712         }
24713         ndr->depth--;
24714 }
24715
24716 static enum ndr_err_code ndr_push_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_push *ndr, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24717 {
24718         if (flags & NDR_IN) {
24719         }
24720         if (flags & NDR_OUT) {
24721                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24722         }
24723         return NDR_ERR_SUCCESS;
24724 }
24725
24726 static enum ndr_err_code ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_pull *ndr, int flags, struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24727 {
24728         if (flags & NDR_IN) {
24729         }
24730         if (flags & NDR_OUT) {
24731                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24732         }
24733         return NDR_ERR_SUCCESS;
24734 }
24735
24736 _PUBLIC_ void ndr_print_spoolss_RouterFindFirstPrinterChangeNotification(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterFindFirstPrinterChangeNotification *r)
24737 {
24738         ndr_print_struct(ndr, name, "spoolss_RouterFindFirstPrinterChangeNotification");
24739         ndr->depth++;
24740         if (flags & NDR_SET_VALUES) {
24741                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24742         }
24743         if (flags & NDR_IN) {
24744                 ndr_print_struct(ndr, "in", "spoolss_RouterFindFirstPrinterChangeNotification");
24745                 ndr->depth++;
24746                 ndr->depth--;
24747         }
24748         if (flags & NDR_OUT) {
24749                 ndr_print_struct(ndr, "out", "spoolss_RouterFindFirstPrinterChangeNotification");
24750                 ndr->depth++;
24751                 ndr_print_WERROR(ndr, "result", r->out.result);
24752                 ndr->depth--;
24753         }
24754         ndr->depth--;
24755 }
24756
24757 static enum ndr_err_code ndr_push_spoolss_SpoolerInit(struct ndr_push *ndr, int flags, const struct spoolss_SpoolerInit *r)
24758 {
24759         if (flags & NDR_IN) {
24760         }
24761         if (flags & NDR_OUT) {
24762                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24763         }
24764         return NDR_ERR_SUCCESS;
24765 }
24766
24767 static enum ndr_err_code ndr_pull_spoolss_SpoolerInit(struct ndr_pull *ndr, int flags, struct spoolss_SpoolerInit *r)
24768 {
24769         if (flags & NDR_IN) {
24770         }
24771         if (flags & NDR_OUT) {
24772                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24773         }
24774         return NDR_ERR_SUCCESS;
24775 }
24776
24777 _PUBLIC_ void ndr_print_spoolss_SpoolerInit(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SpoolerInit *r)
24778 {
24779         ndr_print_struct(ndr, name, "spoolss_SpoolerInit");
24780         ndr->depth++;
24781         if (flags & NDR_SET_VALUES) {
24782                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24783         }
24784         if (flags & NDR_IN) {
24785                 ndr_print_struct(ndr, "in", "spoolss_SpoolerInit");
24786                 ndr->depth++;
24787                 ndr->depth--;
24788         }
24789         if (flags & NDR_OUT) {
24790                 ndr_print_struct(ndr, "out", "spoolss_SpoolerInit");
24791                 ndr->depth++;
24792                 ndr_print_WERROR(ndr, "result", r->out.result);
24793                 ndr->depth--;
24794         }
24795         ndr->depth--;
24796 }
24797
24798 static enum ndr_err_code ndr_push_spoolss_ResetPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_ResetPrinterEx *r)
24799 {
24800         if (flags & NDR_IN) {
24801         }
24802         if (flags & NDR_OUT) {
24803                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24804         }
24805         return NDR_ERR_SUCCESS;
24806 }
24807
24808 static enum ndr_err_code ndr_pull_spoolss_ResetPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_ResetPrinterEx *r)
24809 {
24810         if (flags & NDR_IN) {
24811         }
24812         if (flags & NDR_OUT) {
24813                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24814         }
24815         return NDR_ERR_SUCCESS;
24816 }
24817
24818 _PUBLIC_ void ndr_print_spoolss_ResetPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_ResetPrinterEx *r)
24819 {
24820         ndr_print_struct(ndr, name, "spoolss_ResetPrinterEx");
24821         ndr->depth++;
24822         if (flags & NDR_SET_VALUES) {
24823                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24824         }
24825         if (flags & NDR_IN) {
24826                 ndr_print_struct(ndr, "in", "spoolss_ResetPrinterEx");
24827                 ndr->depth++;
24828                 ndr->depth--;
24829         }
24830         if (flags & NDR_OUT) {
24831                 ndr_print_struct(ndr, "out", "spoolss_ResetPrinterEx");
24832                 ndr->depth++;
24833                 ndr_print_WERROR(ndr, "result", r->out.result);
24834                 ndr->depth--;
24835         }
24836         ndr->depth--;
24837 }
24838
24839 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_push *ndr, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24840 {
24841         if (flags & NDR_IN) {
24842                 if (r->in.handle == NULL) {
24843                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24844                 }
24845                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24846                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24847                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.options));
24848                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.local_machine));
24849                 if (r->in.local_machine) {
24850                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24851                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
24852                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.local_machine, CH_UTF16)));
24853                         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));
24854                 }
24855                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.printer_local));
24856                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.notify_options));
24857                 if (r->in.notify_options) {
24858                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24859                 }
24860         }
24861         if (flags & NDR_OUT) {
24862                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24863         }
24864         return NDR_ERR_SUCCESS;
24865 }
24866
24867 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_pull *ndr, int flags, struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24868 {
24869         uint32_t _ptr_local_machine;
24870         uint32_t _ptr_notify_options;
24871         TALLOC_CTX *_mem_save_handle_0;
24872         TALLOC_CTX *_mem_save_local_machine_0;
24873         TALLOC_CTX *_mem_save_notify_options_0;
24874         if (flags & NDR_IN) {
24875                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24876                         NDR_PULL_ALLOC(ndr, r->in.handle);
24877                 }
24878                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24879                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24880                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24881                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24882                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
24883                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.options));
24884                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_local_machine));
24885                 if (_ptr_local_machine) {
24886                         NDR_PULL_ALLOC(ndr, r->in.local_machine);
24887                 } else {
24888                         r->in.local_machine = NULL;
24889                 }
24890                 if (r->in.local_machine) {
24891                         _mem_save_local_machine_0 = NDR_PULL_GET_MEM_CTX(ndr);
24892                         NDR_PULL_SET_MEM_CTX(ndr, r->in.local_machine, 0);
24893                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.local_machine));
24894                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.local_machine));
24895                         if (ndr_get_array_length(ndr, &r->in.local_machine) > ndr_get_array_size(ndr, &r->in.local_machine)) {
24896                                 return 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));
24897                         }
24898                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.local_machine), sizeof(uint16_t)));
24899                         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));
24900                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_local_machine_0, 0);
24901                 }
24902                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.printer_local));
24903                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_notify_options));
24904                 if (_ptr_notify_options) {
24905                         NDR_PULL_ALLOC(ndr, r->in.notify_options);
24906                 } else {
24907                         r->in.notify_options = NULL;
24908                 }
24909                 if (r->in.notify_options) {
24910                         _mem_save_notify_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
24911                         NDR_PULL_SET_MEM_CTX(ndr, r->in.notify_options, 0);
24912                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.notify_options));
24913                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_notify_options_0, 0);
24914                 }
24915         }
24916         if (flags & NDR_OUT) {
24917                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
24918         }
24919         return NDR_ERR_SUCCESS;
24920 }
24921
24922 _PUBLIC_ void ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RemoteFindFirstPrinterChangeNotifyEx *r)
24923 {
24924         ndr_print_struct(ndr, name, "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24925         ndr->depth++;
24926         if (flags & NDR_SET_VALUES) {
24927                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
24928         }
24929         if (flags & NDR_IN) {
24930                 ndr_print_struct(ndr, "in", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24931                 ndr->depth++;
24932                 ndr_print_ptr(ndr, "handle", r->in.handle);
24933                 ndr->depth++;
24934                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
24935                 ndr->depth--;
24936                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
24937                 ndr_print_uint32(ndr, "options", r->in.options);
24938                 ndr_print_ptr(ndr, "local_machine", r->in.local_machine);
24939                 ndr->depth++;
24940                 if (r->in.local_machine) {
24941                         ndr_print_string(ndr, "local_machine", r->in.local_machine);
24942                 }
24943                 ndr->depth--;
24944                 ndr_print_uint32(ndr, "printer_local", r->in.printer_local);
24945                 ndr_print_ptr(ndr, "notify_options", r->in.notify_options);
24946                 ndr->depth++;
24947                 if (r->in.notify_options) {
24948                         ndr_print_spoolss_NotifyOption(ndr, "notify_options", r->in.notify_options);
24949                 }
24950                 ndr->depth--;
24951                 ndr->depth--;
24952         }
24953         if (flags & NDR_OUT) {
24954                 ndr_print_struct(ndr, "out", "spoolss_RemoteFindFirstPrinterChangeNotifyEx");
24955                 ndr->depth++;
24956                 ndr_print_WERROR(ndr, "result", r->out.result);
24957                 ndr->depth--;
24958         }
24959         ndr->depth--;
24960 }
24961
24962 static enum ndr_err_code ndr_push_spoolss_RouterReplyPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_RouterReplyPrinterEx *r)
24963 {
24964         if (flags & NDR_IN) {
24965                 if (r->in.handle == NULL) {
24966                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24967                 }
24968                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24969                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.color));
24970                 NDR_CHECK(ndr_push_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, r->in.flags));
24971                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.reply_type));
24972                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.info, r->in.reply_type));
24973                 NDR_CHECK(ndr_push_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
24974         }
24975         if (flags & NDR_OUT) {
24976                 if (r->out.reply_result == NULL) {
24977                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
24978                 }
24979                 NDR_CHECK(ndr_push_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, *r->out.reply_result));
24980                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
24981         }
24982         return NDR_ERR_SUCCESS;
24983 }
24984
24985 static enum ndr_err_code ndr_pull_spoolss_RouterReplyPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_RouterReplyPrinterEx *r)
24986 {
24987         TALLOC_CTX *_mem_save_handle_0;
24988         TALLOC_CTX *_mem_save_reply_result_0;
24989         if (flags & NDR_IN) {
24990                 ZERO_STRUCT(r->out);
24991
24992                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
24993                         NDR_PULL_ALLOC(ndr, r->in.handle);
24994                 }
24995                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
24996                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
24997                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
24998                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
24999                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.color));
25000                 NDR_CHECK(ndr_pull_spoolss_PrinterChangeFlags(ndr, NDR_SCALARS, &r->in.flags));
25001                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.reply_type));
25002                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.info, r->in.reply_type));
25003                 NDR_CHECK(ndr_pull_spoolss_ReplyPrinterInfo(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
25004                 NDR_PULL_ALLOC(ndr, r->out.reply_result);
25005                 ZERO_STRUCTP(r->out.reply_result);
25006         }
25007         if (flags & NDR_OUT) {
25008                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25009                         NDR_PULL_ALLOC(ndr, r->out.reply_result);
25010                 }
25011                 _mem_save_reply_result_0 = NDR_PULL_GET_MEM_CTX(ndr);
25012                 NDR_PULL_SET_MEM_CTX(ndr, r->out.reply_result, LIBNDR_FLAG_REF_ALLOC);
25013                 NDR_CHECK(ndr_pull_spoolss_PrinterNotifyFlags(ndr, NDR_SCALARS, r->out.reply_result));
25014                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_reply_result_0, LIBNDR_FLAG_REF_ALLOC);
25015                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25016         }
25017         return NDR_ERR_SUCCESS;
25018 }
25019
25020 _PUBLIC_ void ndr_print_spoolss_RouterReplyPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterReplyPrinterEx *r)
25021 {
25022         ndr_print_struct(ndr, name, "spoolss_RouterReplyPrinterEx");
25023         ndr->depth++;
25024         if (flags & NDR_SET_VALUES) {
25025                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25026         }
25027         if (flags & NDR_IN) {
25028                 ndr_print_struct(ndr, "in", "spoolss_RouterReplyPrinterEx");
25029                 ndr->depth++;
25030                 ndr_print_ptr(ndr, "handle", r->in.handle);
25031                 ndr->depth++;
25032                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25033                 ndr->depth--;
25034                 ndr_print_uint32(ndr, "color", r->in.color);
25035                 ndr_print_spoolss_PrinterChangeFlags(ndr, "flags", r->in.flags);
25036                 ndr_print_uint32(ndr, "reply_type", r->in.reply_type);
25037                 ndr_print_set_switch_value(ndr, &r->in.info, r->in.reply_type);
25038                 ndr_print_spoolss_ReplyPrinterInfo(ndr, "info", &r->in.info);
25039                 ndr->depth--;
25040         }
25041         if (flags & NDR_OUT) {
25042                 ndr_print_struct(ndr, "out", "spoolss_RouterReplyPrinterEx");
25043                 ndr->depth++;
25044                 ndr_print_ptr(ndr, "reply_result", r->out.reply_result);
25045                 ndr->depth++;
25046                 ndr_print_spoolss_PrinterNotifyFlags(ndr, "reply_result", *r->out.reply_result);
25047                 ndr->depth--;
25048                 ndr_print_WERROR(ndr, "result", r->out.result);
25049                 ndr->depth--;
25050         }
25051         ndr->depth--;
25052 }
25053
25054 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_push *ndr, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25055 {
25056         if (flags & NDR_IN) {
25057                 if (r->in.handle == NULL) {
25058                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25059                 }
25060                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25061                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.change_low));
25062                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.options));
25063                 if (r->in.options) {
25064                         NDR_CHECK(ndr_push_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25065                 }
25066         }
25067         if (flags & NDR_OUT) {
25068                 if (r->out.info == NULL) {
25069                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25070                 }
25071                 NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.info));
25072                 if (*r->out.info) {
25073                         NDR_CHECK(ndr_push_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25074                 }
25075                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25076         }
25077         return NDR_ERR_SUCCESS;
25078 }
25079
25080 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_pull *ndr, int flags, struct spoolss_RouterRefreshPrinterChangeNotify *r)
25081 {
25082         uint32_t _ptr_options;
25083         uint32_t _ptr_info;
25084         TALLOC_CTX *_mem_save_handle_0;
25085         TALLOC_CTX *_mem_save_options_0;
25086         TALLOC_CTX *_mem_save_info_0;
25087         TALLOC_CTX *_mem_save_info_1;
25088         if (flags & NDR_IN) {
25089                 ZERO_STRUCT(r->out);
25090
25091                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25092                         NDR_PULL_ALLOC(ndr, r->in.handle);
25093                 }
25094                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25095                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25096                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25097                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25098                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.change_low));
25099                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_options));
25100                 if (_ptr_options) {
25101                         NDR_PULL_ALLOC(ndr, r->in.options);
25102                 } else {
25103                         r->in.options = NULL;
25104                 }
25105                 if (r->in.options) {
25106                         _mem_save_options_0 = NDR_PULL_GET_MEM_CTX(ndr);
25107                         NDR_PULL_SET_MEM_CTX(ndr, r->in.options, 0);
25108                         NDR_CHECK(ndr_pull_spoolss_NotifyOption(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.options));
25109                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_options_0, 0);
25110                 }
25111                 NDR_PULL_ALLOC(ndr, r->out.info);
25112                 ZERO_STRUCTP(r->out.info);
25113         }
25114         if (flags & NDR_OUT) {
25115                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25116                         NDR_PULL_ALLOC(ndr, r->out.info);
25117                 }
25118                 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
25119                 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, LIBNDR_FLAG_REF_ALLOC);
25120                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_info));
25121                 if (_ptr_info) {
25122                         NDR_PULL_ALLOC(ndr, *r->out.info);
25123                 } else {
25124                         *r->out.info = NULL;
25125                 }
25126                 if (*r->out.info) {
25127                         _mem_save_info_1 = NDR_PULL_GET_MEM_CTX(ndr);
25128                         NDR_PULL_SET_MEM_CTX(ndr, *r->out.info, 0);
25129                         NDR_CHECK(ndr_pull_spoolss_NotifyInfo(ndr, NDR_SCALARS|NDR_BUFFERS, *r->out.info));
25130                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_1, 0);
25131                 }
25132                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, LIBNDR_FLAG_REF_ALLOC);
25133                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25134         }
25135         return NDR_ERR_SUCCESS;
25136 }
25137
25138 _PUBLIC_ void ndr_print_spoolss_RouterRefreshPrinterChangeNotify(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_RouterRefreshPrinterChangeNotify *r)
25139 {
25140         ndr_print_struct(ndr, name, "spoolss_RouterRefreshPrinterChangeNotify");
25141         ndr->depth++;
25142         if (flags & NDR_SET_VALUES) {
25143                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25144         }
25145         if (flags & NDR_IN) {
25146                 ndr_print_struct(ndr, "in", "spoolss_RouterRefreshPrinterChangeNotify");
25147                 ndr->depth++;
25148                 ndr_print_ptr(ndr, "handle", r->in.handle);
25149                 ndr->depth++;
25150                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25151                 ndr->depth--;
25152                 ndr_print_uint32(ndr, "change_low", r->in.change_low);
25153                 ndr_print_ptr(ndr, "options", r->in.options);
25154                 ndr->depth++;
25155                 if (r->in.options) {
25156                         ndr_print_spoolss_NotifyOption(ndr, "options", r->in.options);
25157                 }
25158                 ndr->depth--;
25159                 ndr->depth--;
25160         }
25161         if (flags & NDR_OUT) {
25162                 ndr_print_struct(ndr, "out", "spoolss_RouterRefreshPrinterChangeNotify");
25163                 ndr->depth++;
25164                 ndr_print_ptr(ndr, "info", r->out.info);
25165                 ndr->depth++;
25166                 ndr_print_ptr(ndr, "info", *r->out.info);
25167                 ndr->depth++;
25168                 if (*r->out.info) {
25169                         ndr_print_spoolss_NotifyInfo(ndr, "info", *r->out.info);
25170                 }
25171                 ndr->depth--;
25172                 ndr->depth--;
25173                 ndr_print_WERROR(ndr, "result", r->out.result);
25174                 ndr->depth--;
25175         }
25176         ndr->depth--;
25177 }
25178
25179 static enum ndr_err_code ndr_push_spoolss_44(struct ndr_push *ndr, int flags, const struct spoolss_44 *r)
25180 {
25181         if (flags & NDR_IN) {
25182         }
25183         if (flags & NDR_OUT) {
25184                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25185         }
25186         return NDR_ERR_SUCCESS;
25187 }
25188
25189 static enum ndr_err_code ndr_pull_spoolss_44(struct ndr_pull *ndr, int flags, struct spoolss_44 *r)
25190 {
25191         if (flags & NDR_IN) {
25192         }
25193         if (flags & NDR_OUT) {
25194                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25195         }
25196         return NDR_ERR_SUCCESS;
25197 }
25198
25199 _PUBLIC_ void ndr_print_spoolss_44(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_44 *r)
25200 {
25201         ndr_print_struct(ndr, name, "spoolss_44");
25202         ndr->depth++;
25203         if (flags & NDR_SET_VALUES) {
25204                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25205         }
25206         if (flags & NDR_IN) {
25207                 ndr_print_struct(ndr, "in", "spoolss_44");
25208                 ndr->depth++;
25209                 ndr->depth--;
25210         }
25211         if (flags & NDR_OUT) {
25212                 ndr_print_struct(ndr, "out", "spoolss_44");
25213                 ndr->depth++;
25214                 ndr_print_WERROR(ndr, "result", r->out.result);
25215                 ndr->depth--;
25216         }
25217         ndr->depth--;
25218 }
25219
25220 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_OpenPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_OpenPrinterEx *r)
25221 {
25222         if (flags & NDR_IN) {
25223                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.printername));
25224                 if (r->in.printername) {
25225                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25226                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25227                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.printername, CH_UTF16)));
25228                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.printername, ndr_charset_length(r->in.printername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25229                 }
25230                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.datatype));
25231                 if (r->in.datatype) {
25232                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25233                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25234                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.datatype, CH_UTF16)));
25235                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.datatype, ndr_charset_length(r->in.datatype, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25236                 }
25237                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25238                 NDR_CHECK(ndr_push_spoolss_AccessRights(ndr, NDR_SCALARS, r->in.access_mask));
25239                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.level));
25240                 NDR_CHECK(ndr_push_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25241                 NDR_CHECK(ndr_push_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25242         }
25243         if (flags & NDR_OUT) {
25244                 if (r->out.handle == NULL) {
25245                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25246                 }
25247                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25248                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25249         }
25250         return NDR_ERR_SUCCESS;
25251 }
25252
25253 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_OpenPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_OpenPrinterEx *r)
25254 {
25255         uint32_t _ptr_printername;
25256         uint32_t _ptr_datatype;
25257         TALLOC_CTX *_mem_save_printername_0;
25258         TALLOC_CTX *_mem_save_datatype_0;
25259         TALLOC_CTX *_mem_save_handle_0;
25260         if (flags & NDR_IN) {
25261                 ZERO_STRUCT(r->out);
25262
25263                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_printername));
25264                 if (_ptr_printername) {
25265                         NDR_PULL_ALLOC(ndr, r->in.printername);
25266                 } else {
25267                         r->in.printername = NULL;
25268                 }
25269                 if (r->in.printername) {
25270                         _mem_save_printername_0 = NDR_PULL_GET_MEM_CTX(ndr);
25271                         NDR_PULL_SET_MEM_CTX(ndr, r->in.printername, 0);
25272                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.printername));
25273                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.printername));
25274                         if (ndr_get_array_length(ndr, &r->in.printername) > ndr_get_array_size(ndr, &r->in.printername)) {
25275                                 return 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));
25276                         }
25277                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t)));
25278                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.printername, ndr_get_array_length(ndr, &r->in.printername), sizeof(uint16_t), CH_UTF16));
25279                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_printername_0, 0);
25280                 }
25281                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_datatype));
25282                 if (_ptr_datatype) {
25283                         NDR_PULL_ALLOC(ndr, r->in.datatype);
25284                 } else {
25285                         r->in.datatype = NULL;
25286                 }
25287                 if (r->in.datatype) {
25288                         _mem_save_datatype_0 = NDR_PULL_GET_MEM_CTX(ndr);
25289                         NDR_PULL_SET_MEM_CTX(ndr, r->in.datatype, 0);
25290                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.datatype));
25291                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.datatype));
25292                         if (ndr_get_array_length(ndr, &r->in.datatype) > ndr_get_array_size(ndr, &r->in.datatype)) {
25293                                 return ndr_pull_error(ndr, NDR_ERR_ARRAY_SIZE, "Bad array size %u should exceed array length %u", ndr_get_array_size(ndr, &r->in.datatype), ndr_get_array_length(ndr, &r->in.datatype));
25294                         }
25295                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t)));
25296                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.datatype, ndr_get_array_length(ndr, &r->in.datatype), sizeof(uint16_t), CH_UTF16));
25297                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_datatype_0, 0);
25298                 }
25299                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.devmode_ctr));
25300                 NDR_CHECK(ndr_pull_spoolss_AccessRights(ndr, NDR_SCALARS, &r->in.access_mask));
25301                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.level));
25302                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->in.userlevel, r->in.level));
25303                 NDR_CHECK(ndr_pull_spoolss_UserLevel(ndr, NDR_SCALARS|NDR_BUFFERS, &r->in.userlevel));
25304                 NDR_PULL_ALLOC(ndr, r->out.handle);
25305                 ZERO_STRUCTP(r->out.handle);
25306         }
25307         if (flags & NDR_OUT) {
25308                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25309                         NDR_PULL_ALLOC(ndr, r->out.handle);
25310                 }
25311                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25312                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25313                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25314                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25315                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25316         }
25317         return NDR_ERR_SUCCESS;
25318 }
25319
25320 _PUBLIC_ void ndr_print_spoolss_OpenPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_OpenPrinterEx *r)
25321 {
25322         ndr_print_struct(ndr, name, "spoolss_OpenPrinterEx");
25323         ndr->depth++;
25324         if (flags & NDR_SET_VALUES) {
25325                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25326         }
25327         if (flags & NDR_IN) {
25328                 ndr_print_struct(ndr, "in", "spoolss_OpenPrinterEx");
25329                 ndr->depth++;
25330                 ndr_print_ptr(ndr, "printername", r->in.printername);
25331                 ndr->depth++;
25332                 if (r->in.printername) {
25333                         ndr_print_string(ndr, "printername", r->in.printername);
25334                 }
25335                 ndr->depth--;
25336                 ndr_print_ptr(ndr, "datatype", r->in.datatype);
25337                 ndr->depth++;
25338                 if (r->in.datatype) {
25339                         ndr_print_string(ndr, "datatype", r->in.datatype);
25340                 }
25341                 ndr->depth--;
25342                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", &r->in.devmode_ctr);
25343                 ndr_print_spoolss_AccessRights(ndr, "access_mask", r->in.access_mask);
25344                 ndr_print_uint32(ndr, "level", r->in.level);
25345                 ndr_print_set_switch_value(ndr, &r->in.userlevel, r->in.level);
25346                 ndr_print_spoolss_UserLevel(ndr, "userlevel", &r->in.userlevel);
25347                 ndr->depth--;
25348         }
25349         if (flags & NDR_OUT) {
25350                 ndr_print_struct(ndr, "out", "spoolss_OpenPrinterEx");
25351                 ndr->depth++;
25352                 ndr_print_ptr(ndr, "handle", r->out.handle);
25353                 ndr->depth++;
25354                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25355                 ndr->depth--;
25356                 ndr_print_WERROR(ndr, "result", r->out.result);
25357                 ndr->depth--;
25358         }
25359         ndr->depth--;
25360 }
25361
25362 static enum ndr_err_code ndr_push_spoolss_AddPrinterEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterEx *r)
25363 {
25364         if (flags & NDR_IN) {
25365                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
25366                 if (r->in.server) {
25367                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25368                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25369                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
25370                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
25371                 }
25372                 if (r->in.info_ctr == NULL) {
25373                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25374                 }
25375                 NDR_CHECK(ndr_push_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25376                 if (r->in.devmode_ctr == NULL) {
25377                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25378                 }
25379                 NDR_CHECK(ndr_push_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25380                 if (r->in.secdesc_ctr == NULL) {
25381                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25382                 }
25383                 NDR_CHECK(ndr_push_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25384                 if (r->in.userlevel_ctr == NULL) {
25385                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25386                 }
25387                 NDR_CHECK(ndr_push_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25388         }
25389         if (flags & NDR_OUT) {
25390                 if (r->out.handle == NULL) {
25391                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25392                 }
25393                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25394                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25395         }
25396         return NDR_ERR_SUCCESS;
25397 }
25398
25399 static enum ndr_err_code ndr_pull_spoolss_AddPrinterEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterEx *r)
25400 {
25401         uint32_t _ptr_server;
25402         TALLOC_CTX *_mem_save_server_0;
25403         TALLOC_CTX *_mem_save_info_ctr_0;
25404         TALLOC_CTX *_mem_save_devmode_ctr_0;
25405         TALLOC_CTX *_mem_save_secdesc_ctr_0;
25406         TALLOC_CTX *_mem_save_userlevel_ctr_0;
25407         TALLOC_CTX *_mem_save_handle_0;
25408         if (flags & NDR_IN) {
25409                 ZERO_STRUCT(r->out);
25410
25411                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
25412                 if (_ptr_server) {
25413                         NDR_PULL_ALLOC(ndr, r->in.server);
25414                 } else {
25415                         r->in.server = NULL;
25416                 }
25417                 if (r->in.server) {
25418                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
25419                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
25420                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
25421                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
25422                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
25423                                 return 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));
25424                         }
25425                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
25426                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
25427                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
25428                 }
25429                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25430                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
25431                 }
25432                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25433                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
25434                 NDR_CHECK(ndr_pull_spoolss_SetPrinterInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
25435                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25436                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25437                         NDR_PULL_ALLOC(ndr, r->in.devmode_ctr);
25438                 }
25439                 _mem_save_devmode_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25440                 NDR_PULL_SET_MEM_CTX(ndr, r->in.devmode_ctr, LIBNDR_FLAG_REF_ALLOC);
25441                 NDR_CHECK(ndr_pull_spoolss_DevmodeContainer(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.devmode_ctr));
25442                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_devmode_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25443                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25444                         NDR_PULL_ALLOC(ndr, r->in.secdesc_ctr);
25445                 }
25446                 _mem_save_secdesc_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25447                 NDR_PULL_SET_MEM_CTX(ndr, r->in.secdesc_ctr, LIBNDR_FLAG_REF_ALLOC);
25448                 NDR_CHECK(ndr_pull_sec_desc_buf(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.secdesc_ctr));
25449                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_secdesc_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25450                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25451                         NDR_PULL_ALLOC(ndr, r->in.userlevel_ctr);
25452                 }
25453                 _mem_save_userlevel_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
25454                 NDR_PULL_SET_MEM_CTX(ndr, r->in.userlevel_ctr, LIBNDR_FLAG_REF_ALLOC);
25455                 NDR_CHECK(ndr_pull_spoolss_UserLevelCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.userlevel_ctr));
25456                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_userlevel_ctr_0, LIBNDR_FLAG_REF_ALLOC);
25457                 NDR_PULL_ALLOC(ndr, r->out.handle);
25458                 ZERO_STRUCTP(r->out.handle);
25459         }
25460         if (flags & NDR_OUT) {
25461                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25462                         NDR_PULL_ALLOC(ndr, r->out.handle);
25463                 }
25464                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25465                 NDR_PULL_SET_MEM_CTX(ndr, r->out.handle, LIBNDR_FLAG_REF_ALLOC);
25466                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->out.handle));
25467                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25468                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25469         }
25470         return NDR_ERR_SUCCESS;
25471 }
25472
25473 _PUBLIC_ void ndr_print_spoolss_AddPrinterEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterEx *r)
25474 {
25475         ndr_print_struct(ndr, name, "spoolss_AddPrinterEx");
25476         ndr->depth++;
25477         if (flags & NDR_SET_VALUES) {
25478                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25479         }
25480         if (flags & NDR_IN) {
25481                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterEx");
25482                 ndr->depth++;
25483                 ndr_print_ptr(ndr, "server", r->in.server);
25484                 ndr->depth++;
25485                 if (r->in.server) {
25486                         ndr_print_string(ndr, "server", r->in.server);
25487                 }
25488                 ndr->depth--;
25489                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
25490                 ndr->depth++;
25491                 ndr_print_spoolss_SetPrinterInfoCtr(ndr, "info_ctr", r->in.info_ctr);
25492                 ndr->depth--;
25493                 ndr_print_ptr(ndr, "devmode_ctr", r->in.devmode_ctr);
25494                 ndr->depth++;
25495                 ndr_print_spoolss_DevmodeContainer(ndr, "devmode_ctr", r->in.devmode_ctr);
25496                 ndr->depth--;
25497                 ndr_print_ptr(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25498                 ndr->depth++;
25499                 ndr_print_sec_desc_buf(ndr, "secdesc_ctr", r->in.secdesc_ctr);
25500                 ndr->depth--;
25501                 ndr_print_ptr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25502                 ndr->depth++;
25503                 ndr_print_spoolss_UserLevelCtr(ndr, "userlevel_ctr", r->in.userlevel_ctr);
25504                 ndr->depth--;
25505                 ndr->depth--;
25506         }
25507         if (flags & NDR_OUT) {
25508                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterEx");
25509                 ndr->depth++;
25510                 ndr_print_ptr(ndr, "handle", r->out.handle);
25511                 ndr->depth++;
25512                 ndr_print_policy_handle(ndr, "handle", r->out.handle);
25513                 ndr->depth--;
25514                 ndr_print_WERROR(ndr, "result", r->out.result);
25515                 ndr->depth--;
25516         }
25517         ndr->depth--;
25518 }
25519
25520 static enum ndr_err_code ndr_push_spoolss_47(struct ndr_push *ndr, int flags, const struct spoolss_47 *r)
25521 {
25522         if (flags & NDR_IN) {
25523         }
25524         if (flags & NDR_OUT) {
25525                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25526         }
25527         return NDR_ERR_SUCCESS;
25528 }
25529
25530 static enum ndr_err_code ndr_pull_spoolss_47(struct ndr_pull *ndr, int flags, struct spoolss_47 *r)
25531 {
25532         if (flags & NDR_IN) {
25533         }
25534         if (flags & NDR_OUT) {
25535                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25536         }
25537         return NDR_ERR_SUCCESS;
25538 }
25539
25540 _PUBLIC_ void ndr_print_spoolss_47(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_47 *r)
25541 {
25542         ndr_print_struct(ndr, name, "spoolss_47");
25543         ndr->depth++;
25544         if (flags & NDR_SET_VALUES) {
25545                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25546         }
25547         if (flags & NDR_IN) {
25548                 ndr_print_struct(ndr, "in", "spoolss_47");
25549                 ndr->depth++;
25550                 ndr->depth--;
25551         }
25552         if (flags & NDR_OUT) {
25553                 ndr_print_struct(ndr, "out", "spoolss_47");
25554                 ndr->depth++;
25555                 ndr_print_WERROR(ndr, "result", r->out.result);
25556                 ndr->depth--;
25557         }
25558         ndr->depth--;
25559 }
25560
25561 static enum ndr_err_code ndr_push_spoolss_EnumPrinterData(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterData *r)
25562 {
25563         if (flags & NDR_IN) {
25564                 if (r->in.handle == NULL) {
25565                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25566                 }
25567                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25568                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.enum_index));
25569                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered));
25570                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25571         }
25572         if (flags & NDR_OUT) {
25573                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.value_offered / 2));
25574                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->out.value_name, r->in.value_offered / 2, sizeof(uint16_t), CH_UTF16));
25575                 if (r->out.value_needed == NULL) {
25576                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25577                 }
25578                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.value_needed));
25579                 if (r->out.type == NULL) {
25580                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25581                 }
25582                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
25583                 {
25584                         uint32_t _flags_save_uint8 = ndr->flags;
25585                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25586                         if (r->out.data == NULL) {
25587                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25588                         }
25589                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.data_offered));
25590                         NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.data, r->in.data_offered));
25591                         ndr->flags = _flags_save_uint8;
25592                 }
25593                 if (r->out.data_needed == NULL) {
25594                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25595                 }
25596                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.data_needed));
25597                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25598         }
25599         return NDR_ERR_SUCCESS;
25600 }
25601
25602 static enum ndr_err_code ndr_pull_spoolss_EnumPrinterData(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterData *r)
25603 {
25604         TALLOC_CTX *_mem_save_handle_0;
25605         TALLOC_CTX *_mem_save_value_needed_0;
25606         TALLOC_CTX *_mem_save_type_0;
25607         TALLOC_CTX *_mem_save_data_needed_0;
25608         if (flags & NDR_IN) {
25609                 ZERO_STRUCT(r->out);
25610
25611                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25612                         NDR_PULL_ALLOC(ndr, r->in.handle);
25613                 }
25614                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25615                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25616                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25617                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25618                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.enum_index));
25619                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.value_offered));
25620                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.data_offered));
25621                 NDR_PULL_ALLOC(ndr, r->out.value_needed);
25622                 ZERO_STRUCTP(r->out.value_needed);
25623                 NDR_PULL_ALLOC(ndr, r->out.type);
25624                 ZERO_STRUCTP(r->out.type);
25625                 NDR_PULL_ALLOC_N(ndr, r->out.data, r->in.data_offered);
25626                 memset(r->out.data, 0, (r->in.data_offered) * sizeof(*r->out.data));
25627                 NDR_PULL_ALLOC(ndr, r->out.data_needed);
25628                 ZERO_STRUCTP(r->out.data_needed);
25629         }
25630         if (flags & NDR_OUT) {
25631                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.value_name));
25632                 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));
25633                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25634                         NDR_PULL_ALLOC(ndr, r->out.value_needed);
25635                 }
25636                 _mem_save_value_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25637                 NDR_PULL_SET_MEM_CTX(ndr, r->out.value_needed, LIBNDR_FLAG_REF_ALLOC);
25638                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.value_needed));
25639                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_value_needed_0, LIBNDR_FLAG_REF_ALLOC);
25640                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25641                         NDR_PULL_ALLOC(ndr, r->out.type);
25642                 }
25643                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
25644                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
25645                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
25646                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
25647                 {
25648                         uint32_t _flags_save_uint8 = ndr->flags;
25649                         ndr_set_flags(&ndr->flags, LIBNDR_PRINT_ARRAY_HEX);
25650                         NDR_CHECK(ndr_pull_array_size(ndr, &r->out.data));
25651                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25652                                 NDR_PULL_ALLOC_N(ndr, r->out.data, ndr_get_array_size(ndr, &r->out.data));
25653                         }
25654                         NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.data, ndr_get_array_size(ndr, &r->out.data)));
25655                         ndr->flags = _flags_save_uint8;
25656                 }
25657                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25658                         NDR_PULL_ALLOC(ndr, r->out.data_needed);
25659                 }
25660                 _mem_save_data_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
25661                 NDR_PULL_SET_MEM_CTX(ndr, r->out.data_needed, LIBNDR_FLAG_REF_ALLOC);
25662                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.data_needed));
25663                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_data_needed_0, LIBNDR_FLAG_REF_ALLOC);
25664                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25665                 if (r->out.value_name) {
25666                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.value_name, r->in.value_offered / 2));
25667                 }
25668                 if (r->out.data) {
25669                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.data, r->in.data_offered));
25670                 }
25671         }
25672         return NDR_ERR_SUCCESS;
25673 }
25674
25675 _PUBLIC_ void ndr_print_spoolss_EnumPrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterData *r)
25676 {
25677         ndr_print_struct(ndr, name, "spoolss_EnumPrinterData");
25678         ndr->depth++;
25679         if (flags & NDR_SET_VALUES) {
25680                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25681         }
25682         if (flags & NDR_IN) {
25683                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterData");
25684                 ndr->depth++;
25685                 ndr_print_ptr(ndr, "handle", r->in.handle);
25686                 ndr->depth++;
25687                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25688                 ndr->depth--;
25689                 ndr_print_uint32(ndr, "enum_index", r->in.enum_index);
25690                 ndr_print_uint32(ndr, "value_offered", r->in.value_offered);
25691                 ndr_print_uint32(ndr, "data_offered", r->in.data_offered);
25692                 ndr->depth--;
25693         }
25694         if (flags & NDR_OUT) {
25695                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterData");
25696                 ndr->depth++;
25697                 ndr_print_string(ndr, "value_name", r->out.value_name);
25698                 ndr_print_ptr(ndr, "value_needed", r->out.value_needed);
25699                 ndr->depth++;
25700                 ndr_print_uint32(ndr, "value_needed", *r->out.value_needed);
25701                 ndr->depth--;
25702                 ndr_print_ptr(ndr, "type", r->out.type);
25703                 ndr->depth++;
25704                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
25705                 ndr->depth--;
25706                 ndr_print_ptr(ndr, "data", r->out.data);
25707                 ndr->depth++;
25708                 ndr_print_array_uint8(ndr, "data", r->out.data, r->in.data_offered);
25709                 ndr->depth--;
25710                 ndr_print_ptr(ndr, "data_needed", r->out.data_needed);
25711                 ndr->depth++;
25712                 ndr_print_uint32(ndr, "data_needed", *r->out.data_needed);
25713                 ndr->depth--;
25714                 ndr_print_WERROR(ndr, "result", r->out.result);
25715                 ndr->depth--;
25716         }
25717         ndr->depth--;
25718 }
25719
25720 static enum ndr_err_code ndr_push_spoolss_DeletePrinterData(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterData *r)
25721 {
25722         if (flags & NDR_IN) {
25723                 if (r->in.handle == NULL) {
25724                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25725                 }
25726                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25727                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25728                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25729                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25730                 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));
25731         }
25732         if (flags & NDR_OUT) {
25733                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25734         }
25735         return NDR_ERR_SUCCESS;
25736 }
25737
25738 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterData(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterData *r)
25739 {
25740         TALLOC_CTX *_mem_save_handle_0;
25741         if (flags & NDR_IN) {
25742                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25743                         NDR_PULL_ALLOC(ndr, r->in.handle);
25744                 }
25745                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25746                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25747                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25748                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25749                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25750                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25751                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25752                         return 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));
25753                 }
25754                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25755                 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));
25756         }
25757         if (flags & NDR_OUT) {
25758                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25759         }
25760         return NDR_ERR_SUCCESS;
25761 }
25762
25763 _PUBLIC_ void ndr_print_spoolss_DeletePrinterData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterData *r)
25764 {
25765         ndr_print_struct(ndr, name, "spoolss_DeletePrinterData");
25766         ndr->depth++;
25767         if (flags & NDR_SET_VALUES) {
25768                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25769         }
25770         if (flags & NDR_IN) {
25771                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterData");
25772                 ndr->depth++;
25773                 ndr_print_ptr(ndr, "handle", r->in.handle);
25774                 ndr->depth++;
25775                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25776                 ndr->depth--;
25777                 ndr_print_string(ndr, "value_name", r->in.value_name);
25778                 ndr->depth--;
25779         }
25780         if (flags & NDR_OUT) {
25781                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterData");
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_4a(struct ndr_push *ndr, int flags, const struct spoolss_4a *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_4a(struct ndr_pull *ndr, int flags, struct spoolss_4a *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_4a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4a *r)
25810 {
25811         ndr_print_struct(ndr, name, "spoolss_4a");
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_4a");
25818                 ndr->depth++;
25819                 ndr->depth--;
25820         }
25821         if (flags & NDR_OUT) {
25822                 ndr_print_struct(ndr, "out", "spoolss_4a");
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_4b(struct ndr_push *ndr, int flags, const struct spoolss_4b *r)
25831 {
25832         if (flags & NDR_IN) {
25833         }
25834         if (flags & NDR_OUT) {
25835                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25836         }
25837         return NDR_ERR_SUCCESS;
25838 }
25839
25840 static enum ndr_err_code ndr_pull_spoolss_4b(struct ndr_pull *ndr, int flags, struct spoolss_4b *r)
25841 {
25842         if (flags & NDR_IN) {
25843         }
25844         if (flags & NDR_OUT) {
25845                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25846         }
25847         return NDR_ERR_SUCCESS;
25848 }
25849
25850 _PUBLIC_ void ndr_print_spoolss_4b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4b *r)
25851 {
25852         ndr_print_struct(ndr, name, "spoolss_4b");
25853         ndr->depth++;
25854         if (flags & NDR_SET_VALUES) {
25855                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25856         }
25857         if (flags & NDR_IN) {
25858                 ndr_print_struct(ndr, "in", "spoolss_4b");
25859                 ndr->depth++;
25860                 ndr->depth--;
25861         }
25862         if (flags & NDR_OUT) {
25863                 ndr_print_struct(ndr, "out", "spoolss_4b");
25864                 ndr->depth++;
25865                 ndr_print_WERROR(ndr, "result", r->out.result);
25866                 ndr->depth--;
25867         }
25868         ndr->depth--;
25869 }
25870
25871 static enum ndr_err_code ndr_push_spoolss_4c(struct ndr_push *ndr, int flags, const struct spoolss_4c *r)
25872 {
25873         if (flags & NDR_IN) {
25874         }
25875         if (flags & NDR_OUT) {
25876                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25877         }
25878         return NDR_ERR_SUCCESS;
25879 }
25880
25881 static enum ndr_err_code ndr_pull_spoolss_4c(struct ndr_pull *ndr, int flags, struct spoolss_4c *r)
25882 {
25883         if (flags & NDR_IN) {
25884         }
25885         if (flags & NDR_OUT) {
25886                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25887         }
25888         return NDR_ERR_SUCCESS;
25889 }
25890
25891 _PUBLIC_ void ndr_print_spoolss_4c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_4c *r)
25892 {
25893         ndr_print_struct(ndr, name, "spoolss_4c");
25894         ndr->depth++;
25895         if (flags & NDR_SET_VALUES) {
25896                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25897         }
25898         if (flags & NDR_IN) {
25899                 ndr_print_struct(ndr, "in", "spoolss_4c");
25900                 ndr->depth++;
25901                 ndr->depth--;
25902         }
25903         if (flags & NDR_OUT) {
25904                 ndr_print_struct(ndr, "out", "spoolss_4c");
25905                 ndr->depth++;
25906                 ndr_print_WERROR(ndr, "result", r->out.result);
25907                 ndr->depth--;
25908         }
25909         ndr->depth--;
25910 }
25911
25912 static enum ndr_err_code ndr_push_spoolss_SetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_SetPrinterDataEx *r)
25913 {
25914         if (flags & NDR_IN) {
25915                 if (r->in.handle == NULL) {
25916                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25917                 }
25918                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25919                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25920                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25921                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
25922                 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));
25923                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25924                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
25925                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
25926                 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));
25927                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, r->in.type));
25928                 if (r->in.buffer == NULL) {
25929                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
25930                 }
25931                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25932                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->in.buffer, r->in.offered));
25933                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
25934         }
25935         if (flags & NDR_OUT) {
25936                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
25937         }
25938         return NDR_ERR_SUCCESS;
25939 }
25940
25941 static enum ndr_err_code ndr_pull_spoolss_SetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_SetPrinterDataEx *r)
25942 {
25943         TALLOC_CTX *_mem_save_handle_0;
25944         if (flags & NDR_IN) {
25945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25946                         NDR_PULL_ALLOC(ndr, r->in.handle);
25947                 }
25948                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
25949                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
25950                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
25951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
25952                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
25953                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
25954                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
25955                         return 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));
25956                 }
25957                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
25958                 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));
25959                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
25960                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
25961                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
25962                         return 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));
25963                 }
25964                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
25965                 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));
25966                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, &r->in.type));
25967                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.buffer));
25968                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
25969                         NDR_PULL_ALLOC_N(ndr, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer));
25970                 }
25971                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->in.buffer, ndr_get_array_size(ndr, &r->in.buffer)));
25972                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
25973                 if (r->in.buffer) {
25974                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->in.buffer, r->in.offered));
25975                 }
25976         }
25977         if (flags & NDR_OUT) {
25978                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
25979         }
25980         return NDR_ERR_SUCCESS;
25981 }
25982
25983 _PUBLIC_ void ndr_print_spoolss_SetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_SetPrinterDataEx *r)
25984 {
25985         ndr_print_struct(ndr, name, "spoolss_SetPrinterDataEx");
25986         ndr->depth++;
25987         if (flags & NDR_SET_VALUES) {
25988                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
25989         }
25990         if (flags & NDR_IN) {
25991                 ndr_print_struct(ndr, "in", "spoolss_SetPrinterDataEx");
25992                 ndr->depth++;
25993                 ndr_print_ptr(ndr, "handle", r->in.handle);
25994                 ndr->depth++;
25995                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
25996                 ndr->depth--;
25997                 ndr_print_string(ndr, "key_name", r->in.key_name);
25998                 ndr_print_string(ndr, "value_name", r->in.value_name);
25999                 ndr_print_winreg_Type(ndr, "type", r->in.type);
26000                 ndr_print_ptr(ndr, "buffer", r->in.buffer);
26001                 ndr->depth++;
26002                 ndr_print_array_uint8(ndr, "buffer", r->in.buffer, r->in.offered);
26003                 ndr->depth--;
26004                 ndr_print_uint32(ndr, "offered", r->in.offered);
26005                 ndr->depth--;
26006         }
26007         if (flags & NDR_OUT) {
26008                 ndr_print_struct(ndr, "out", "spoolss_SetPrinterDataEx");
26009                 ndr->depth++;
26010                 ndr_print_WERROR(ndr, "result", r->out.result);
26011                 ndr->depth--;
26012         }
26013         ndr->depth--;
26014 }
26015
26016 static enum ndr_err_code ndr_push_spoolss_GetPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_GetPrinterDataEx *r)
26017 {
26018         if (flags & NDR_IN) {
26019                 if (r->in.handle == NULL) {
26020                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26021                 }
26022                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26023                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26024                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26025                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26026                 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));
26027                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26028                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26029                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26030                 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));
26031                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26032         }
26033         if (flags & NDR_OUT) {
26034                 if (r->out.type == NULL) {
26035                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26036                 }
26037                 NDR_CHECK(ndr_push_winreg_Type(ndr, NDR_SCALARS, *r->out.type));
26038                 if (r->out.buffer == NULL) {
26039                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26040                 }
26041                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26042                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26043                 if (r->out.needed == NULL) {
26044                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26045                 }
26046                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26047                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26048         }
26049         return NDR_ERR_SUCCESS;
26050 }
26051
26052 static enum ndr_err_code ndr_pull_spoolss_GetPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_GetPrinterDataEx *r)
26053 {
26054         TALLOC_CTX *_mem_save_handle_0;
26055         TALLOC_CTX *_mem_save_type_0;
26056         TALLOC_CTX *_mem_save_needed_0;
26057         if (flags & NDR_IN) {
26058                 ZERO_STRUCT(r->out);
26059
26060                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26061                         NDR_PULL_ALLOC(ndr, r->in.handle);
26062                 }
26063                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26064                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26065                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26066                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26067                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26068                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26069                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26070                         return 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));
26071                 }
26072                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26073                 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));
26074                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26075                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26076                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26077                         return 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));
26078                 }
26079                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26080                 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));
26081                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26082                 NDR_PULL_ALLOC(ndr, r->out.type);
26083                 ZERO_STRUCTP(r->out.type);
26084                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26085                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26086                 NDR_PULL_ALLOC(ndr, r->out.needed);
26087                 ZERO_STRUCTP(r->out.needed);
26088         }
26089         if (flags & NDR_OUT) {
26090                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26091                         NDR_PULL_ALLOC(ndr, r->out.type);
26092                 }
26093                 _mem_save_type_0 = NDR_PULL_GET_MEM_CTX(ndr);
26094                 NDR_PULL_SET_MEM_CTX(ndr, r->out.type, LIBNDR_FLAG_REF_ALLOC);
26095                 NDR_CHECK(ndr_pull_winreg_Type(ndr, NDR_SCALARS, r->out.type));
26096                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_type_0, LIBNDR_FLAG_REF_ALLOC);
26097                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26098                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26099                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26100                 }
26101                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26102                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26103                         NDR_PULL_ALLOC(ndr, r->out.needed);
26104                 }
26105                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26106                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26107                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26108                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26109                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26110                 if (r->out.buffer) {
26111                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26112                 }
26113         }
26114         return NDR_ERR_SUCCESS;
26115 }
26116
26117 _PUBLIC_ void ndr_print_spoolss_GetPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_GetPrinterDataEx *r)
26118 {
26119         ndr_print_struct(ndr, name, "spoolss_GetPrinterDataEx");
26120         ndr->depth++;
26121         if (flags & NDR_SET_VALUES) {
26122                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26123         }
26124         if (flags & NDR_IN) {
26125                 ndr_print_struct(ndr, "in", "spoolss_GetPrinterDataEx");
26126                 ndr->depth++;
26127                 ndr_print_ptr(ndr, "handle", r->in.handle);
26128                 ndr->depth++;
26129                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26130                 ndr->depth--;
26131                 ndr_print_string(ndr, "key_name", r->in.key_name);
26132                 ndr_print_string(ndr, "value_name", r->in.value_name);
26133                 ndr_print_uint32(ndr, "offered", r->in.offered);
26134                 ndr->depth--;
26135         }
26136         if (flags & NDR_OUT) {
26137                 ndr_print_struct(ndr, "out", "spoolss_GetPrinterDataEx");
26138                 ndr->depth++;
26139                 ndr_print_ptr(ndr, "type", r->out.type);
26140                 ndr->depth++;
26141                 ndr_print_winreg_Type(ndr, "type", *r->out.type);
26142                 ndr->depth--;
26143                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26144                 ndr->depth++;
26145                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26146                 ndr->depth--;
26147                 ndr_print_ptr(ndr, "needed", r->out.needed);
26148                 ndr->depth++;
26149                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26150                 ndr->depth--;
26151                 ndr_print_WERROR(ndr, "result", r->out.result);
26152                 ndr->depth--;
26153         }
26154         ndr->depth--;
26155 }
26156
26157 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterDataEx *r)
26158 {
26159         if (flags & NDR_IN) {
26160                 if (r->in.handle == NULL) {
26161                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26162                 }
26163                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26164                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26165                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26166                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26167                 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));
26168                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26169         }
26170         if (flags & NDR_OUT) {
26171                 if (r->out.buffer == NULL) {
26172                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26173                 }
26174                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26175                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.buffer, r->in.offered));
26176                 if (r->out.needed == NULL) {
26177                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26178                 }
26179                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26180                 if (r->out.count == NULL) {
26181                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26182                 }
26183                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.count));
26184                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26185         }
26186         return NDR_ERR_SUCCESS;
26187 }
26188
26189 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterDataEx *r)
26190 {
26191         TALLOC_CTX *_mem_save_handle_0;
26192         TALLOC_CTX *_mem_save_needed_0;
26193         TALLOC_CTX *_mem_save_count_0;
26194         if (flags & NDR_IN) {
26195                 ZERO_STRUCT(r->out);
26196
26197                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26198                         NDR_PULL_ALLOC(ndr, r->in.handle);
26199                 }
26200                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26201                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26202                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26203                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26204                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26205                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26206                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26207                         return 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));
26208                 }
26209                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26210                 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));
26211                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26212                 NDR_PULL_ALLOC_N(ndr, r->out.buffer, r->in.offered);
26213                 memset(r->out.buffer, 0, (r->in.offered) * sizeof(*r->out.buffer));
26214                 NDR_PULL_ALLOC(ndr, r->out.needed);
26215                 ZERO_STRUCTP(r->out.needed);
26216                 NDR_PULL_ALLOC(ndr, r->out.count);
26217                 ZERO_STRUCTP(r->out.count);
26218         }
26219         if (flags & NDR_OUT) {
26220                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.buffer));
26221                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26222                         NDR_PULL_ALLOC_N(ndr, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer));
26223                 }
26224                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.buffer, ndr_get_array_size(ndr, &r->out.buffer)));
26225                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26226                         NDR_PULL_ALLOC(ndr, r->out.needed);
26227                 }
26228                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26229                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26230                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26231                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26232                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26233                         NDR_PULL_ALLOC(ndr, r->out.count);
26234                 }
26235                 _mem_save_count_0 = NDR_PULL_GET_MEM_CTX(ndr);
26236                 NDR_PULL_SET_MEM_CTX(ndr, r->out.count, LIBNDR_FLAG_REF_ALLOC);
26237                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.count));
26238                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_count_0, LIBNDR_FLAG_REF_ALLOC);
26239                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26240                 if (r->out.buffer) {
26241                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.buffer, r->in.offered));
26242                 }
26243         }
26244         return NDR_ERR_SUCCESS;
26245 }
26246
26247 _PUBLIC_ void ndr_print_spoolss_EnumPrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterDataEx *r)
26248 {
26249         ndr_print_struct(ndr, name, "spoolss_EnumPrinterDataEx");
26250         ndr->depth++;
26251         if (flags & NDR_SET_VALUES) {
26252                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26253         }
26254         if (flags & NDR_IN) {
26255                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterDataEx");
26256                 ndr->depth++;
26257                 ndr_print_ptr(ndr, "handle", r->in.handle);
26258                 ndr->depth++;
26259                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26260                 ndr->depth--;
26261                 ndr_print_string(ndr, "key_name", r->in.key_name);
26262                 ndr_print_uint32(ndr, "offered", r->in.offered);
26263                 ndr->depth--;
26264         }
26265         if (flags & NDR_OUT) {
26266                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterDataEx");
26267                 ndr->depth++;
26268                 ndr_print_ptr(ndr, "buffer", r->out.buffer);
26269                 ndr->depth++;
26270                 ndr_print_array_uint8(ndr, "buffer", r->out.buffer, r->in.offered);
26271                 ndr->depth--;
26272                 ndr_print_ptr(ndr, "needed", r->out.needed);
26273                 ndr->depth++;
26274                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26275                 ndr->depth--;
26276                 ndr_print_ptr(ndr, "count", r->out.count);
26277                 ndr->depth++;
26278                 ndr_print_uint32(ndr, "count", *r->out.count);
26279                 ndr->depth--;
26280                 ndr_print_WERROR(ndr, "result", r->out.result);
26281                 ndr->depth--;
26282         }
26283         ndr->depth--;
26284 }
26285
26286 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_EnumPrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_EnumPrinterKey *r)
26287 {
26288         if (flags & NDR_IN) {
26289                 if (r->in.handle == NULL) {
26290                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26291                 }
26292                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26293                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26294                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26295                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26296                 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));
26297                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.offered));
26298         }
26299         if (flags & NDR_OUT) {
26300                 {
26301                         uint32_t _flags_save_string_array = ndr->flags;
26302                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26303                         if (r->out.key_buffer == NULL) {
26304                                 return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26305                         }
26306                         NDR_CHECK(ndr_push_unique_ptr(ndr, *r->out.key_buffer));
26307                         if (*r->out.key_buffer) {
26308                                 {
26309                                         struct ndr_push *_ndr_key_buffer;
26310                                         NDR_CHECK(ndr_push_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26311                                         NDR_CHECK(ndr_push_string_array(_ndr_key_buffer, NDR_SCALARS, *r->out.key_buffer));
26312                                         NDR_CHECK(ndr_push_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26313                                 }
26314                         }
26315                         ndr->flags = _flags_save_string_array;
26316                 }
26317                 if (r->out.needed == NULL) {
26318                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26319                 }
26320                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26321                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26322         }
26323         return NDR_ERR_SUCCESS;
26324 }
26325
26326 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_EnumPrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_EnumPrinterKey *r)
26327 {
26328         uint32_t _ptr_key_buffer;
26329         TALLOC_CTX *_mem_save_handle_0;
26330         TALLOC_CTX *_mem_save_key_buffer_0;
26331         TALLOC_CTX *_mem_save_key_buffer_1;
26332         TALLOC_CTX *_mem_save_needed_0;
26333         if (flags & NDR_IN) {
26334                 ZERO_STRUCT(r->out);
26335
26336                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26337                         NDR_PULL_ALLOC(ndr, r->in.handle);
26338                 }
26339                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26340                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26341                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26342                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26343                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26344                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26345                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_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.key_name), ndr_get_array_length(ndr, &r->in.key_name));
26347                 }
26348                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26349                 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));
26350                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.offered));
26351                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26352                 ZERO_STRUCTP(r->out.key_buffer);
26353                 NDR_PULL_ALLOC(ndr, r->out.needed);
26354                 ZERO_STRUCTP(r->out.needed);
26355         }
26356         if (flags & NDR_OUT) {
26357                 {
26358                         uint32_t _flags_save_string_array = ndr->flags;
26359                         ndr_set_flags(&ndr->flags, LIBNDR_FLAG_STR_NULLTERM);
26360                         if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26361                                 NDR_PULL_ALLOC(ndr, r->out.key_buffer);
26362                         }
26363                         _mem_save_key_buffer_0 = NDR_PULL_GET_MEM_CTX(ndr);
26364                         NDR_PULL_SET_MEM_CTX(ndr, r->out.key_buffer, LIBNDR_FLAG_REF_ALLOC);
26365                         NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_key_buffer));
26366                         if (_ptr_key_buffer) {
26367                                 NDR_PULL_ALLOC(ndr, *r->out.key_buffer);
26368                         } else {
26369                                 *r->out.key_buffer = NULL;
26370                         }
26371                         if (*r->out.key_buffer) {
26372                                 _mem_save_key_buffer_1 = NDR_PULL_GET_MEM_CTX(ndr);
26373                                 NDR_PULL_SET_MEM_CTX(ndr, *r->out.key_buffer, 0);
26374                                 {
26375                                         struct ndr_pull *_ndr_key_buffer;
26376                                         NDR_CHECK(ndr_pull_subcontext_start(ndr, &_ndr_key_buffer, 0, r->in.offered));
26377                                         NDR_CHECK(ndr_pull_string_array(_ndr_key_buffer, NDR_SCALARS, r->out.key_buffer));
26378                                         NDR_CHECK(ndr_pull_subcontext_end(ndr, _ndr_key_buffer, 0, r->in.offered));
26379                                 }
26380                                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_1, 0);
26381                         }
26382                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_key_buffer_0, LIBNDR_FLAG_REF_ALLOC);
26383                         ndr->flags = _flags_save_string_array;
26384                 }
26385                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26386                         NDR_PULL_ALLOC(ndr, r->out.needed);
26387                 }
26388                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26389                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26390                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26391                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26392                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26393         }
26394         return NDR_ERR_SUCCESS;
26395 }
26396
26397 _PUBLIC_ void ndr_print_spoolss_EnumPrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_EnumPrinterKey *r)
26398 {
26399         ndr_print_struct(ndr, name, "spoolss_EnumPrinterKey");
26400         ndr->depth++;
26401         if (flags & NDR_SET_VALUES) {
26402                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26403         }
26404         if (flags & NDR_IN) {
26405                 ndr_print_struct(ndr, "in", "spoolss_EnumPrinterKey");
26406                 ndr->depth++;
26407                 ndr_print_ptr(ndr, "handle", r->in.handle);
26408                 ndr->depth++;
26409                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26410                 ndr->depth--;
26411                 ndr_print_string(ndr, "key_name", r->in.key_name);
26412                 ndr_print_uint32(ndr, "offered", r->in.offered);
26413                 ndr->depth--;
26414         }
26415         if (flags & NDR_OUT) {
26416                 ndr_print_struct(ndr, "out", "spoolss_EnumPrinterKey");
26417                 ndr->depth++;
26418                 ndr_print_ptr(ndr, "key_buffer", r->out.key_buffer);
26419                 ndr->depth++;
26420                 ndr_print_ptr(ndr, "key_buffer", *r->out.key_buffer);
26421                 ndr->depth++;
26422                 if (*r->out.key_buffer) {
26423                         ndr_print_string_array(ndr, "key_buffer", *r->out.key_buffer);
26424                 }
26425                 ndr->depth--;
26426                 ndr->depth--;
26427                 ndr_print_ptr(ndr, "needed", r->out.needed);
26428                 ndr->depth++;
26429                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26430                 ndr->depth--;
26431                 ndr_print_WERROR(ndr, "result", r->out.result);
26432                 ndr->depth--;
26433         }
26434         ndr->depth--;
26435 }
26436
26437 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDataEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDataEx *r)
26438 {
26439         if (flags & NDR_IN) {
26440                 if (r->in.handle == NULL) {
26441                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26442                 }
26443                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26444                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26445                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26446                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26447                 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));
26448                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26449                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26450                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.value_name, CH_UTF16)));
26451                 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));
26452         }
26453         if (flags & NDR_OUT) {
26454                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26455         }
26456         return NDR_ERR_SUCCESS;
26457 }
26458
26459 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDataEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDataEx *r)
26460 {
26461         TALLOC_CTX *_mem_save_handle_0;
26462         if (flags & NDR_IN) {
26463                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26464                         NDR_PULL_ALLOC(ndr, r->in.handle);
26465                 }
26466                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26467                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26468                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26469                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26470                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26471                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26472                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26473                         return 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));
26474                 }
26475                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26476                 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));
26477                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.value_name));
26478                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.value_name));
26479                 if (ndr_get_array_length(ndr, &r->in.value_name) > ndr_get_array_size(ndr, &r->in.value_name)) {
26480                         return 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));
26481                 }
26482                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.value_name), sizeof(uint16_t)));
26483                 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));
26484         }
26485         if (flags & NDR_OUT) {
26486                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26487         }
26488         return NDR_ERR_SUCCESS;
26489 }
26490
26491 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDataEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDataEx *r)
26492 {
26493         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDataEx");
26494         ndr->depth++;
26495         if (flags & NDR_SET_VALUES) {
26496                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26497         }
26498         if (flags & NDR_IN) {
26499                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDataEx");
26500                 ndr->depth++;
26501                 ndr_print_ptr(ndr, "handle", r->in.handle);
26502                 ndr->depth++;
26503                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26504                 ndr->depth--;
26505                 ndr_print_string(ndr, "key_name", r->in.key_name);
26506                 ndr_print_string(ndr, "value_name", r->in.value_name);
26507                 ndr->depth--;
26508         }
26509         if (flags & NDR_OUT) {
26510                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDataEx");
26511                 ndr->depth++;
26512                 ndr_print_WERROR(ndr, "result", r->out.result);
26513                 ndr->depth--;
26514         }
26515         ndr->depth--;
26516 }
26517
26518 static enum ndr_err_code ndr_push_spoolss_DeletePrinterKey(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterKey *r)
26519 {
26520         if (flags & NDR_IN) {
26521                 if (r->in.handle == NULL) {
26522                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26523                 }
26524                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26525                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26526                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26527                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.key_name, CH_UTF16)));
26528                 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));
26529         }
26530         if (flags & NDR_OUT) {
26531                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26532         }
26533         return NDR_ERR_SUCCESS;
26534 }
26535
26536 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterKey(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterKey *r)
26537 {
26538         TALLOC_CTX *_mem_save_handle_0;
26539         if (flags & NDR_IN) {
26540                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26541                         NDR_PULL_ALLOC(ndr, r->in.handle);
26542                 }
26543                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26544                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26545                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26546                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26547                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.key_name));
26548                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.key_name));
26549                 if (ndr_get_array_length(ndr, &r->in.key_name) > ndr_get_array_size(ndr, &r->in.key_name)) {
26550                         return 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));
26551                 }
26552                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.key_name), sizeof(uint16_t)));
26553                 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));
26554         }
26555         if (flags & NDR_OUT) {
26556                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26557         }
26558         return NDR_ERR_SUCCESS;
26559 }
26560
26561 _PUBLIC_ void ndr_print_spoolss_DeletePrinterKey(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterKey *r)
26562 {
26563         ndr_print_struct(ndr, name, "spoolss_DeletePrinterKey");
26564         ndr->depth++;
26565         if (flags & NDR_SET_VALUES) {
26566                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26567         }
26568         if (flags & NDR_IN) {
26569                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterKey");
26570                 ndr->depth++;
26571                 ndr_print_ptr(ndr, "handle", r->in.handle);
26572                 ndr->depth++;
26573                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26574                 ndr->depth--;
26575                 ndr_print_string(ndr, "key_name", r->in.key_name);
26576                 ndr->depth--;
26577         }
26578         if (flags & NDR_OUT) {
26579                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterKey");
26580                 ndr->depth++;
26581                 ndr_print_WERROR(ndr, "result", r->out.result);
26582                 ndr->depth--;
26583         }
26584         ndr->depth--;
26585 }
26586
26587 static enum ndr_err_code ndr_push_spoolss_53(struct ndr_push *ndr, int flags, const struct spoolss_53 *r)
26588 {
26589         if (flags & NDR_IN) {
26590         }
26591         if (flags & NDR_OUT) {
26592                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26593         }
26594         return NDR_ERR_SUCCESS;
26595 }
26596
26597 static enum ndr_err_code ndr_pull_spoolss_53(struct ndr_pull *ndr, int flags, struct spoolss_53 *r)
26598 {
26599         if (flags & NDR_IN) {
26600         }
26601         if (flags & NDR_OUT) {
26602                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26603         }
26604         return NDR_ERR_SUCCESS;
26605 }
26606
26607 _PUBLIC_ void ndr_print_spoolss_53(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_53 *r)
26608 {
26609         ndr_print_struct(ndr, name, "spoolss_53");
26610         ndr->depth++;
26611         if (flags & NDR_SET_VALUES) {
26612                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26613         }
26614         if (flags & NDR_IN) {
26615                 ndr_print_struct(ndr, "in", "spoolss_53");
26616                 ndr->depth++;
26617                 ndr->depth--;
26618         }
26619         if (flags & NDR_OUT) {
26620                 ndr_print_struct(ndr, "out", "spoolss_53");
26621                 ndr->depth++;
26622                 ndr_print_WERROR(ndr, "result", r->out.result);
26623                 ndr->depth--;
26624         }
26625         ndr->depth--;
26626 }
26627
26628 static enum ndr_err_code ndr_push_spoolss_DeletePrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26629 {
26630         if (flags & NDR_IN) {
26631                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.server));
26632                 if (r->in.server) {
26633                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26634                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26635                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.server, CH_UTF16)));
26636                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.server, ndr_charset_length(r->in.server, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26637                 }
26638                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26639                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26640                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.architecture, CH_UTF16)));
26641                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.architecture, ndr_charset_length(r->in.architecture, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26642                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26643                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26644                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.driver, CH_UTF16)));
26645                 NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.driver, ndr_charset_length(r->in.driver, CH_UTF16), sizeof(uint16_t), CH_UTF16));
26646                 NDR_CHECK(ndr_push_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, r->in.delete_flags));
26647                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.version));
26648         }
26649         if (flags & NDR_OUT) {
26650                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26651         }
26652         return NDR_ERR_SUCCESS;
26653 }
26654
26655 static enum ndr_err_code ndr_pull_spoolss_DeletePrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_DeletePrinterDriverEx *r)
26656 {
26657         uint32_t _ptr_server;
26658         TALLOC_CTX *_mem_save_server_0;
26659         if (flags & NDR_IN) {
26660                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_server));
26661                 if (_ptr_server) {
26662                         NDR_PULL_ALLOC(ndr, r->in.server);
26663                 } else {
26664                         r->in.server = NULL;
26665                 }
26666                 if (r->in.server) {
26667                         _mem_save_server_0 = NDR_PULL_GET_MEM_CTX(ndr);
26668                         NDR_PULL_SET_MEM_CTX(ndr, r->in.server, 0);
26669                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.server));
26670                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.server));
26671                         if (ndr_get_array_length(ndr, &r->in.server) > ndr_get_array_size(ndr, &r->in.server)) {
26672                                 return 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));
26673                         }
26674                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t)));
26675                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.server, ndr_get_array_length(ndr, &r->in.server), sizeof(uint16_t), CH_UTF16));
26676                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_server_0, 0);
26677                 }
26678                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.architecture));
26679                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.architecture));
26680                 if (ndr_get_array_length(ndr, &r->in.architecture) > ndr_get_array_size(ndr, &r->in.architecture)) {
26681                         return 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));
26682                 }
26683                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t)));
26684                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.architecture, ndr_get_array_length(ndr, &r->in.architecture), sizeof(uint16_t), CH_UTF16));
26685                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.driver));
26686                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.driver));
26687                 if (ndr_get_array_length(ndr, &r->in.driver) > ndr_get_array_size(ndr, &r->in.driver)) {
26688                         return 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));
26689                 }
26690                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t)));
26691                 NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.driver, ndr_get_array_length(ndr, &r->in.driver), sizeof(uint16_t), CH_UTF16));
26692                 NDR_CHECK(ndr_pull_spoolss_DeleteDriverFlags(ndr, NDR_SCALARS, &r->in.delete_flags));
26693                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.version));
26694         }
26695         if (flags & NDR_OUT) {
26696                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26697         }
26698         return NDR_ERR_SUCCESS;
26699 }
26700
26701 _PUBLIC_ void ndr_print_spoolss_DeletePrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_DeletePrinterDriverEx *r)
26702 {
26703         ndr_print_struct(ndr, name, "spoolss_DeletePrinterDriverEx");
26704         ndr->depth++;
26705         if (flags & NDR_SET_VALUES) {
26706                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26707         }
26708         if (flags & NDR_IN) {
26709                 ndr_print_struct(ndr, "in", "spoolss_DeletePrinterDriverEx");
26710                 ndr->depth++;
26711                 ndr_print_ptr(ndr, "server", r->in.server);
26712                 ndr->depth++;
26713                 if (r->in.server) {
26714                         ndr_print_string(ndr, "server", r->in.server);
26715                 }
26716                 ndr->depth--;
26717                 ndr_print_string(ndr, "architecture", r->in.architecture);
26718                 ndr_print_string(ndr, "driver", r->in.driver);
26719                 ndr_print_spoolss_DeleteDriverFlags(ndr, "delete_flags", r->in.delete_flags);
26720                 ndr_print_uint32(ndr, "version", r->in.version);
26721                 ndr->depth--;
26722         }
26723         if (flags & NDR_OUT) {
26724                 ndr_print_struct(ndr, "out", "spoolss_DeletePrinterDriverEx");
26725                 ndr->depth++;
26726                 ndr_print_WERROR(ndr, "result", r->out.result);
26727                 ndr->depth--;
26728         }
26729         ndr->depth--;
26730 }
26731
26732 static enum ndr_err_code ndr_push_spoolss_55(struct ndr_push *ndr, int flags, const struct spoolss_55 *r)
26733 {
26734         if (flags & NDR_IN) {
26735         }
26736         if (flags & NDR_OUT) {
26737                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26738         }
26739         return NDR_ERR_SUCCESS;
26740 }
26741
26742 static enum ndr_err_code ndr_pull_spoolss_55(struct ndr_pull *ndr, int flags, struct spoolss_55 *r)
26743 {
26744         if (flags & NDR_IN) {
26745         }
26746         if (flags & NDR_OUT) {
26747                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26748         }
26749         return NDR_ERR_SUCCESS;
26750 }
26751
26752 _PUBLIC_ void ndr_print_spoolss_55(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_55 *r)
26753 {
26754         ndr_print_struct(ndr, name, "spoolss_55");
26755         ndr->depth++;
26756         if (flags & NDR_SET_VALUES) {
26757                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26758         }
26759         if (flags & NDR_IN) {
26760                 ndr_print_struct(ndr, "in", "spoolss_55");
26761                 ndr->depth++;
26762                 ndr->depth--;
26763         }
26764         if (flags & NDR_OUT) {
26765                 ndr_print_struct(ndr, "out", "spoolss_55");
26766                 ndr->depth++;
26767                 ndr_print_WERROR(ndr, "result", r->out.result);
26768                 ndr->depth--;
26769         }
26770         ndr->depth--;
26771 }
26772
26773 static enum ndr_err_code ndr_push_spoolss_56(struct ndr_push *ndr, int flags, const struct spoolss_56 *r)
26774 {
26775         if (flags & NDR_IN) {
26776         }
26777         if (flags & NDR_OUT) {
26778                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26779         }
26780         return NDR_ERR_SUCCESS;
26781 }
26782
26783 static enum ndr_err_code ndr_pull_spoolss_56(struct ndr_pull *ndr, int flags, struct spoolss_56 *r)
26784 {
26785         if (flags & NDR_IN) {
26786         }
26787         if (flags & NDR_OUT) {
26788                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26789         }
26790         return NDR_ERR_SUCCESS;
26791 }
26792
26793 _PUBLIC_ void ndr_print_spoolss_56(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_56 *r)
26794 {
26795         ndr_print_struct(ndr, name, "spoolss_56");
26796         ndr->depth++;
26797         if (flags & NDR_SET_VALUES) {
26798                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26799         }
26800         if (flags & NDR_IN) {
26801                 ndr_print_struct(ndr, "in", "spoolss_56");
26802                 ndr->depth++;
26803                 ndr->depth--;
26804         }
26805         if (flags & NDR_OUT) {
26806                 ndr_print_struct(ndr, "out", "spoolss_56");
26807                 ndr->depth++;
26808                 ndr_print_WERROR(ndr, "result", r->out.result);
26809                 ndr->depth--;
26810         }
26811         ndr->depth--;
26812 }
26813
26814 static enum ndr_err_code ndr_push_spoolss_57(struct ndr_push *ndr, int flags, const struct spoolss_57 *r)
26815 {
26816         if (flags & NDR_IN) {
26817         }
26818         if (flags & NDR_OUT) {
26819                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26820         }
26821         return NDR_ERR_SUCCESS;
26822 }
26823
26824 static enum ndr_err_code ndr_pull_spoolss_57(struct ndr_pull *ndr, int flags, struct spoolss_57 *r)
26825 {
26826         if (flags & NDR_IN) {
26827         }
26828         if (flags & NDR_OUT) {
26829                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26830         }
26831         return NDR_ERR_SUCCESS;
26832 }
26833
26834 _PUBLIC_ void ndr_print_spoolss_57(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_57 *r)
26835 {
26836         ndr_print_struct(ndr, name, "spoolss_57");
26837         ndr->depth++;
26838         if (flags & NDR_SET_VALUES) {
26839                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26840         }
26841         if (flags & NDR_IN) {
26842                 ndr_print_struct(ndr, "in", "spoolss_57");
26843                 ndr->depth++;
26844                 ndr->depth--;
26845         }
26846         if (flags & NDR_OUT) {
26847                 ndr_print_struct(ndr, "out", "spoolss_57");
26848                 ndr->depth++;
26849                 ndr_print_WERROR(ndr, "result", r->out.result);
26850                 ndr->depth--;
26851         }
26852         ndr->depth--;
26853 }
26854
26855 static enum ndr_err_code ndr_push_spoolss_XcvData(struct ndr_push *ndr, int flags, const struct spoolss_XcvData *r)
26856 {
26857         if (flags & NDR_IN) {
26858                 if (r->in.handle == NULL) {
26859                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26860                 }
26861                 NDR_CHECK(ndr_push_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26862                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26863                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
26864                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.function_name, CH_UTF16)));
26865                 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));
26866                 NDR_CHECK(ndr_push_DATA_BLOB(ndr, NDR_SCALARS, r->in.in_data));
26867                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.in_data.length));
26868                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26869                 if (r->in.status_code == NULL) {
26870                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26871                 }
26872                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->in.status_code));
26873         }
26874         if (flags & NDR_OUT) {
26875                 if (r->out.out_data == NULL) {
26876                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26877                 }
26878                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, r->in.out_data_size));
26879                 NDR_CHECK(ndr_push_array_uint8(ndr, NDR_SCALARS, r->out.out_data, r->in.out_data_size));
26880                 if (r->out.needed == NULL) {
26881                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26882                 }
26883                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.needed));
26884                 if (r->out.status_code == NULL) {
26885                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
26886                 }
26887                 NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, *r->out.status_code));
26888                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
26889         }
26890         return NDR_ERR_SUCCESS;
26891 }
26892
26893 static enum ndr_err_code ndr_pull_spoolss_XcvData(struct ndr_pull *ndr, int flags, struct spoolss_XcvData *r)
26894 {
26895         TALLOC_CTX *_mem_save_handle_0;
26896         TALLOC_CTX *_mem_save_needed_0;
26897         TALLOC_CTX *_mem_save_status_code_0;
26898         if (flags & NDR_IN) {
26899                 ZERO_STRUCT(r->out);
26900
26901                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26902                         NDR_PULL_ALLOC(ndr, r->in.handle);
26903                 }
26904                 _mem_save_handle_0 = NDR_PULL_GET_MEM_CTX(ndr);
26905                 NDR_PULL_SET_MEM_CTX(ndr, r->in.handle, LIBNDR_FLAG_REF_ALLOC);
26906                 NDR_CHECK(ndr_pull_policy_handle(ndr, NDR_SCALARS, r->in.handle));
26907                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_handle_0, LIBNDR_FLAG_REF_ALLOC);
26908                 NDR_CHECK(ndr_pull_array_size(ndr, &r->in.function_name));
26909                 NDR_CHECK(ndr_pull_array_length(ndr, &r->in.function_name));
26910                 if (ndr_get_array_length(ndr, &r->in.function_name) > ndr_get_array_size(ndr, &r->in.function_name)) {
26911                         return 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));
26912                 }
26913                 NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.function_name), sizeof(uint16_t)));
26914                 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));
26915                 NDR_CHECK(ndr_pull_DATA_BLOB(ndr, NDR_SCALARS, &r->in.in_data));
26916                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in._in_data_length));
26917                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, &r->in.out_data_size));
26918                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26919                         NDR_PULL_ALLOC(ndr, r->in.status_code);
26920                 }
26921                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26922                 NDR_PULL_SET_MEM_CTX(ndr, r->in.status_code, LIBNDR_FLAG_REF_ALLOC);
26923                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->in.status_code));
26924                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26925                 NDR_PULL_ALLOC_N(ndr, r->out.out_data, r->in.out_data_size);
26926                 memset(r->out.out_data, 0, (r->in.out_data_size) * sizeof(*r->out.out_data));
26927                 NDR_PULL_ALLOC(ndr, r->out.needed);
26928                 ZERO_STRUCTP(r->out.needed);
26929                 NDR_PULL_ALLOC(ndr, r->out.status_code);
26930                 *r->out.status_code = *r->in.status_code;
26931         }
26932         if (flags & NDR_OUT) {
26933                 NDR_CHECK(ndr_pull_array_size(ndr, &r->out.out_data));
26934                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26935                         NDR_PULL_ALLOC_N(ndr, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data));
26936                 }
26937                 NDR_CHECK(ndr_pull_array_uint8(ndr, NDR_SCALARS, r->out.out_data, ndr_get_array_size(ndr, &r->out.out_data)));
26938                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26939                         NDR_PULL_ALLOC(ndr, r->out.needed);
26940                 }
26941                 _mem_save_needed_0 = NDR_PULL_GET_MEM_CTX(ndr);
26942                 NDR_PULL_SET_MEM_CTX(ndr, r->out.needed, LIBNDR_FLAG_REF_ALLOC);
26943                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.needed));
26944                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_needed_0, LIBNDR_FLAG_REF_ALLOC);
26945                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
26946                         NDR_PULL_ALLOC(ndr, r->out.status_code);
26947                 }
26948                 _mem_save_status_code_0 = NDR_PULL_GET_MEM_CTX(ndr);
26949                 NDR_PULL_SET_MEM_CTX(ndr, r->out.status_code, LIBNDR_FLAG_REF_ALLOC);
26950                 NDR_CHECK(ndr_pull_uint32(ndr, NDR_SCALARS, r->out.status_code));
26951                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_status_code_0, LIBNDR_FLAG_REF_ALLOC);
26952                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
26953                 if (r->out.out_data) {
26954                         NDR_CHECK(ndr_check_array_size(ndr, (void*)&r->out.out_data, r->in.out_data_size));
26955                 }
26956         }
26957         return NDR_ERR_SUCCESS;
26958 }
26959
26960 _PUBLIC_ void ndr_print_spoolss_XcvData(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_XcvData *r)
26961 {
26962         ndr_print_struct(ndr, name, "spoolss_XcvData");
26963         ndr->depth++;
26964         if (flags & NDR_SET_VALUES) {
26965                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
26966         }
26967         if (flags & NDR_IN) {
26968                 ndr_print_struct(ndr, "in", "spoolss_XcvData");
26969                 ndr->depth++;
26970                 ndr_print_ptr(ndr, "handle", r->in.handle);
26971                 ndr->depth++;
26972                 ndr_print_policy_handle(ndr, "handle", r->in.handle);
26973                 ndr->depth--;
26974                 ndr_print_string(ndr, "function_name", r->in.function_name);
26975                 ndr_print_DATA_BLOB(ndr, "in_data", r->in.in_data);
26976                 ndr_print_uint32(ndr, "_in_data_length", (ndr->flags & LIBNDR_PRINT_SET_VALUES)?r->in.in_data.length:r->in._in_data_length);
26977                 ndr_print_uint32(ndr, "out_data_size", r->in.out_data_size);
26978                 ndr_print_ptr(ndr, "status_code", r->in.status_code);
26979                 ndr->depth++;
26980                 ndr_print_uint32(ndr, "status_code", *r->in.status_code);
26981                 ndr->depth--;
26982                 ndr->depth--;
26983         }
26984         if (flags & NDR_OUT) {
26985                 ndr_print_struct(ndr, "out", "spoolss_XcvData");
26986                 ndr->depth++;
26987                 ndr_print_ptr(ndr, "out_data", r->out.out_data);
26988                 ndr->depth++;
26989                 ndr_print_array_uint8(ndr, "out_data", r->out.out_data, r->in.out_data_size);
26990                 ndr->depth--;
26991                 ndr_print_ptr(ndr, "needed", r->out.needed);
26992                 ndr->depth++;
26993                 ndr_print_uint32(ndr, "needed", *r->out.needed);
26994                 ndr->depth--;
26995                 ndr_print_ptr(ndr, "status_code", r->out.status_code);
26996                 ndr->depth++;
26997                 ndr_print_uint32(ndr, "status_code", *r->out.status_code);
26998                 ndr->depth--;
26999                 ndr_print_WERROR(ndr, "result", r->out.result);
27000                 ndr->depth--;
27001         }
27002         ndr->depth--;
27003 }
27004
27005 _PUBLIC_ enum ndr_err_code ndr_push_spoolss_AddPrinterDriverEx(struct ndr_push *ndr, int flags, const struct spoolss_AddPrinterDriverEx *r)
27006 {
27007         if (flags & NDR_IN) {
27008                 NDR_CHECK(ndr_push_unique_ptr(ndr, r->in.servername));
27009                 if (r->in.servername) {
27010                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27011                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, 0));
27012                         NDR_CHECK(ndr_push_uint32(ndr, NDR_SCALARS, ndr_charset_length(r->in.servername, CH_UTF16)));
27013                         NDR_CHECK(ndr_push_charset(ndr, NDR_SCALARS, r->in.servername, ndr_charset_length(r->in.servername, CH_UTF16), sizeof(uint16_t), CH_UTF16));
27014                 }
27015                 if (r->in.info_ctr == NULL) {
27016                         return ndr_push_error(ndr, NDR_ERR_INVALID_POINTER, "NULL [ref] pointer");
27017                 }
27018                 NDR_CHECK(ndr_push_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27019                 NDR_CHECK(ndr_push_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, r->in.flags));
27020         }
27021         if (flags & NDR_OUT) {
27022                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27023         }
27024         return NDR_ERR_SUCCESS;
27025 }
27026
27027 _PUBLIC_ enum ndr_err_code ndr_pull_spoolss_AddPrinterDriverEx(struct ndr_pull *ndr, int flags, struct spoolss_AddPrinterDriverEx *r)
27028 {
27029         uint32_t _ptr_servername;
27030         TALLOC_CTX *_mem_save_servername_0;
27031         TALLOC_CTX *_mem_save_info_ctr_0;
27032         if (flags & NDR_IN) {
27033                 NDR_CHECK(ndr_pull_generic_ptr(ndr, &_ptr_servername));
27034                 if (_ptr_servername) {
27035                         NDR_PULL_ALLOC(ndr, r->in.servername);
27036                 } else {
27037                         r->in.servername = NULL;
27038                 }
27039                 if (r->in.servername) {
27040                         _mem_save_servername_0 = NDR_PULL_GET_MEM_CTX(ndr);
27041                         NDR_PULL_SET_MEM_CTX(ndr, r->in.servername, 0);
27042                         NDR_CHECK(ndr_pull_array_size(ndr, &r->in.servername));
27043                         NDR_CHECK(ndr_pull_array_length(ndr, &r->in.servername));
27044                         if (ndr_get_array_length(ndr, &r->in.servername) > ndr_get_array_size(ndr, &r->in.servername)) {
27045                                 return 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));
27046                         }
27047                         NDR_CHECK(ndr_check_string_terminator(ndr, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t)));
27048                         NDR_CHECK(ndr_pull_charset(ndr, NDR_SCALARS, &r->in.servername, ndr_get_array_length(ndr, &r->in.servername), sizeof(uint16_t), CH_UTF16));
27049                         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_servername_0, 0);
27050                 }
27051                 if (ndr->flags & LIBNDR_FLAG_REF_ALLOC) {
27052                         NDR_PULL_ALLOC(ndr, r->in.info_ctr);
27053                 }
27054                 _mem_save_info_ctr_0 = NDR_PULL_GET_MEM_CTX(ndr);
27055                 NDR_PULL_SET_MEM_CTX(ndr, r->in.info_ctr, LIBNDR_FLAG_REF_ALLOC);
27056                 NDR_CHECK(ndr_pull_spoolss_AddDriverInfoCtr(ndr, NDR_SCALARS|NDR_BUFFERS, r->in.info_ctr));
27057                 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_ctr_0, LIBNDR_FLAG_REF_ALLOC);
27058                 NDR_CHECK(ndr_pull_spoolss_AddPrinterDriverExFlags(ndr, NDR_SCALARS, &r->in.flags));
27059         }
27060         if (flags & NDR_OUT) {
27061                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27062         }
27063         return NDR_ERR_SUCCESS;
27064 }
27065
27066 _PUBLIC_ void ndr_print_spoolss_AddPrinterDriverEx(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_AddPrinterDriverEx *r)
27067 {
27068         ndr_print_struct(ndr, name, "spoolss_AddPrinterDriverEx");
27069         ndr->depth++;
27070         if (flags & NDR_SET_VALUES) {
27071                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27072         }
27073         if (flags & NDR_IN) {
27074                 ndr_print_struct(ndr, "in", "spoolss_AddPrinterDriverEx");
27075                 ndr->depth++;
27076                 ndr_print_ptr(ndr, "servername", r->in.servername);
27077                 ndr->depth++;
27078                 if (r->in.servername) {
27079                         ndr_print_string(ndr, "servername", r->in.servername);
27080                 }
27081                 ndr->depth--;
27082                 ndr_print_ptr(ndr, "info_ctr", r->in.info_ctr);
27083                 ndr->depth++;
27084                 ndr_print_spoolss_AddDriverInfoCtr(ndr, "info_ctr", r->in.info_ctr);
27085                 ndr->depth--;
27086                 ndr_print_spoolss_AddPrinterDriverExFlags(ndr, "flags", r->in.flags);
27087                 ndr->depth--;
27088         }
27089         if (flags & NDR_OUT) {
27090                 ndr_print_struct(ndr, "out", "spoolss_AddPrinterDriverEx");
27091                 ndr->depth++;
27092                 ndr_print_WERROR(ndr, "result", r->out.result);
27093                 ndr->depth--;
27094         }
27095         ndr->depth--;
27096 }
27097
27098 static enum ndr_err_code ndr_push_spoolss_5a(struct ndr_push *ndr, int flags, const struct spoolss_5a *r)
27099 {
27100         if (flags & NDR_IN) {
27101         }
27102         if (flags & NDR_OUT) {
27103                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27104         }
27105         return NDR_ERR_SUCCESS;
27106 }
27107
27108 static enum ndr_err_code ndr_pull_spoolss_5a(struct ndr_pull *ndr, int flags, struct spoolss_5a *r)
27109 {
27110         if (flags & NDR_IN) {
27111         }
27112         if (flags & NDR_OUT) {
27113                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27114         }
27115         return NDR_ERR_SUCCESS;
27116 }
27117
27118 _PUBLIC_ void ndr_print_spoolss_5a(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5a *r)
27119 {
27120         ndr_print_struct(ndr, name, "spoolss_5a");
27121         ndr->depth++;
27122         if (flags & NDR_SET_VALUES) {
27123                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27124         }
27125         if (flags & NDR_IN) {
27126                 ndr_print_struct(ndr, "in", "spoolss_5a");
27127                 ndr->depth++;
27128                 ndr->depth--;
27129         }
27130         if (flags & NDR_OUT) {
27131                 ndr_print_struct(ndr, "out", "spoolss_5a");
27132                 ndr->depth++;
27133                 ndr_print_WERROR(ndr, "result", r->out.result);
27134                 ndr->depth--;
27135         }
27136         ndr->depth--;
27137 }
27138
27139 static enum ndr_err_code ndr_push_spoolss_5b(struct ndr_push *ndr, int flags, const struct spoolss_5b *r)
27140 {
27141         if (flags & NDR_IN) {
27142         }
27143         if (flags & NDR_OUT) {
27144                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27145         }
27146         return NDR_ERR_SUCCESS;
27147 }
27148
27149 static enum ndr_err_code ndr_pull_spoolss_5b(struct ndr_pull *ndr, int flags, struct spoolss_5b *r)
27150 {
27151         if (flags & NDR_IN) {
27152         }
27153         if (flags & NDR_OUT) {
27154                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27155         }
27156         return NDR_ERR_SUCCESS;
27157 }
27158
27159 _PUBLIC_ void ndr_print_spoolss_5b(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5b *r)
27160 {
27161         ndr_print_struct(ndr, name, "spoolss_5b");
27162         ndr->depth++;
27163         if (flags & NDR_SET_VALUES) {
27164                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27165         }
27166         if (flags & NDR_IN) {
27167                 ndr_print_struct(ndr, "in", "spoolss_5b");
27168                 ndr->depth++;
27169                 ndr->depth--;
27170         }
27171         if (flags & NDR_OUT) {
27172                 ndr_print_struct(ndr, "out", "spoolss_5b");
27173                 ndr->depth++;
27174                 ndr_print_WERROR(ndr, "result", r->out.result);
27175                 ndr->depth--;
27176         }
27177         ndr->depth--;
27178 }
27179
27180 static enum ndr_err_code ndr_push_spoolss_5c(struct ndr_push *ndr, int flags, const struct spoolss_5c *r)
27181 {
27182         if (flags & NDR_IN) {
27183         }
27184         if (flags & NDR_OUT) {
27185                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27186         }
27187         return NDR_ERR_SUCCESS;
27188 }
27189
27190 static enum ndr_err_code ndr_pull_spoolss_5c(struct ndr_pull *ndr, int flags, struct spoolss_5c *r)
27191 {
27192         if (flags & NDR_IN) {
27193         }
27194         if (flags & NDR_OUT) {
27195                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27196         }
27197         return NDR_ERR_SUCCESS;
27198 }
27199
27200 _PUBLIC_ void ndr_print_spoolss_5c(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5c *r)
27201 {
27202         ndr_print_struct(ndr, name, "spoolss_5c");
27203         ndr->depth++;
27204         if (flags & NDR_SET_VALUES) {
27205                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27206         }
27207         if (flags & NDR_IN) {
27208                 ndr_print_struct(ndr, "in", "spoolss_5c");
27209                 ndr->depth++;
27210                 ndr->depth--;
27211         }
27212         if (flags & NDR_OUT) {
27213                 ndr_print_struct(ndr, "out", "spoolss_5c");
27214                 ndr->depth++;
27215                 ndr_print_WERROR(ndr, "result", r->out.result);
27216                 ndr->depth--;
27217         }
27218         ndr->depth--;
27219 }
27220
27221 static enum ndr_err_code ndr_push_spoolss_5d(struct ndr_push *ndr, int flags, const struct spoolss_5d *r)
27222 {
27223         if (flags & NDR_IN) {
27224         }
27225         if (flags & NDR_OUT) {
27226                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27227         }
27228         return NDR_ERR_SUCCESS;
27229 }
27230
27231 static enum ndr_err_code ndr_pull_spoolss_5d(struct ndr_pull *ndr, int flags, struct spoolss_5d *r)
27232 {
27233         if (flags & NDR_IN) {
27234         }
27235         if (flags & NDR_OUT) {
27236                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27237         }
27238         return NDR_ERR_SUCCESS;
27239 }
27240
27241 _PUBLIC_ void ndr_print_spoolss_5d(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5d *r)
27242 {
27243         ndr_print_struct(ndr, name, "spoolss_5d");
27244         ndr->depth++;
27245         if (flags & NDR_SET_VALUES) {
27246                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27247         }
27248         if (flags & NDR_IN) {
27249                 ndr_print_struct(ndr, "in", "spoolss_5d");
27250                 ndr->depth++;
27251                 ndr->depth--;
27252         }
27253         if (flags & NDR_OUT) {
27254                 ndr_print_struct(ndr, "out", "spoolss_5d");
27255                 ndr->depth++;
27256                 ndr_print_WERROR(ndr, "result", r->out.result);
27257                 ndr->depth--;
27258         }
27259         ndr->depth--;
27260 }
27261
27262 static enum ndr_err_code ndr_push_spoolss_5e(struct ndr_push *ndr, int flags, const struct spoolss_5e *r)
27263 {
27264         if (flags & NDR_IN) {
27265         }
27266         if (flags & NDR_OUT) {
27267                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27268         }
27269         return NDR_ERR_SUCCESS;
27270 }
27271
27272 static enum ndr_err_code ndr_pull_spoolss_5e(struct ndr_pull *ndr, int flags, struct spoolss_5e *r)
27273 {
27274         if (flags & NDR_IN) {
27275         }
27276         if (flags & NDR_OUT) {
27277                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27278         }
27279         return NDR_ERR_SUCCESS;
27280 }
27281
27282 _PUBLIC_ void ndr_print_spoolss_5e(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5e *r)
27283 {
27284         ndr_print_struct(ndr, name, "spoolss_5e");
27285         ndr->depth++;
27286         if (flags & NDR_SET_VALUES) {
27287                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27288         }
27289         if (flags & NDR_IN) {
27290                 ndr_print_struct(ndr, "in", "spoolss_5e");
27291                 ndr->depth++;
27292                 ndr->depth--;
27293         }
27294         if (flags & NDR_OUT) {
27295                 ndr_print_struct(ndr, "out", "spoolss_5e");
27296                 ndr->depth++;
27297                 ndr_print_WERROR(ndr, "result", r->out.result);
27298                 ndr->depth--;
27299         }
27300         ndr->depth--;
27301 }
27302
27303 static enum ndr_err_code ndr_push_spoolss_5f(struct ndr_push *ndr, int flags, const struct spoolss_5f *r)
27304 {
27305         if (flags & NDR_IN) {
27306         }
27307         if (flags & NDR_OUT) {
27308                 NDR_CHECK(ndr_push_WERROR(ndr, NDR_SCALARS, r->out.result));
27309         }
27310         return NDR_ERR_SUCCESS;
27311 }
27312
27313 static enum ndr_err_code ndr_pull_spoolss_5f(struct ndr_pull *ndr, int flags, struct spoolss_5f *r)
27314 {
27315         if (flags & NDR_IN) {
27316         }
27317         if (flags & NDR_OUT) {
27318                 NDR_CHECK(ndr_pull_WERROR(ndr, NDR_SCALARS, &r->out.result));
27319         }
27320         return NDR_ERR_SUCCESS;
27321 }
27322
27323 _PUBLIC_ void ndr_print_spoolss_5f(struct ndr_print *ndr, const char *name, int flags, const struct spoolss_5f *r)
27324 {
27325         ndr_print_struct(ndr, name, "spoolss_5f");
27326         ndr->depth++;
27327         if (flags & NDR_SET_VALUES) {
27328                 ndr->flags |= LIBNDR_PRINT_SET_VALUES;
27329         }
27330         if (flags & NDR_IN) {
27331                 ndr_print_struct(ndr, "in", "spoolss_5f");
27332                 ndr->depth++;
27333                 ndr->depth--;
27334         }
27335         if (flags & NDR_OUT) {
27336                 ndr_print_struct(ndr, "out", "spoolss_5f");
27337                 ndr->depth++;
27338                 ndr_print_WERROR(ndr, "result", r->out.result);
27339                 ndr->depth--;
27340         }
27341         ndr->depth--;
27342 }
27343
27344 static const struct ndr_interface_call spoolss_calls[] = {
27345         {
27346                 "spoolss_EnumPrinters",
27347                 sizeof(struct spoolss_EnumPrinters),
27348                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinters,
27349                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinters,
27350                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinters,
27351                 false,
27352         },
27353         {
27354                 "spoolss_OpenPrinter",
27355                 sizeof(struct spoolss_OpenPrinter),
27356                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinter,
27357                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinter,
27358                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinter,
27359                 false,
27360         },
27361         {
27362                 "spoolss_SetJob",
27363                 sizeof(struct spoolss_SetJob),
27364                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetJob,
27365                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetJob,
27366                 (ndr_print_function_t) ndr_print_spoolss_SetJob,
27367                 false,
27368         },
27369         {
27370                 "spoolss_GetJob",
27371                 sizeof(struct spoolss_GetJob),
27372                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetJob,
27373                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetJob,
27374                 (ndr_print_function_t) ndr_print_spoolss_GetJob,
27375                 false,
27376         },
27377         {
27378                 "spoolss_EnumJobs",
27379                 sizeof(struct spoolss_EnumJobs),
27380                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumJobs,
27381                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumJobs,
27382                 (ndr_print_function_t) ndr_print_spoolss_EnumJobs,
27383                 false,
27384         },
27385         {
27386                 "spoolss_AddPrinter",
27387                 sizeof(struct spoolss_AddPrinter),
27388                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinter,
27389                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinter,
27390                 (ndr_print_function_t) ndr_print_spoolss_AddPrinter,
27391                 false,
27392         },
27393         {
27394                 "spoolss_DeletePrinter",
27395                 sizeof(struct spoolss_DeletePrinter),
27396                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinter,
27397                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinter,
27398                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinter,
27399                 false,
27400         },
27401         {
27402                 "spoolss_SetPrinter",
27403                 sizeof(struct spoolss_SetPrinter),
27404                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinter,
27405                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinter,
27406                 (ndr_print_function_t) ndr_print_spoolss_SetPrinter,
27407                 false,
27408         },
27409         {
27410                 "spoolss_GetPrinter",
27411                 sizeof(struct spoolss_GetPrinter),
27412                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinter,
27413                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinter,
27414                 (ndr_print_function_t) ndr_print_spoolss_GetPrinter,
27415                 false,
27416         },
27417         {
27418                 "spoolss_AddPrinterDriver",
27419                 sizeof(struct spoolss_AddPrinterDriver),
27420                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriver,
27421                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriver,
27422                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriver,
27423                 false,
27424         },
27425         {
27426                 "spoolss_EnumPrinterDrivers",
27427                 sizeof(struct spoolss_EnumPrinterDrivers),
27428                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDrivers,
27429                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDrivers,
27430                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDrivers,
27431                 false,
27432         },
27433         {
27434                 "spoolss_GetPrinterDriver",
27435                 sizeof(struct spoolss_GetPrinterDriver),
27436                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver,
27437                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver,
27438                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver,
27439                 false,
27440         },
27441         {
27442                 "spoolss_GetPrinterDriverDirectory",
27443                 sizeof(struct spoolss_GetPrinterDriverDirectory),
27444                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriverDirectory,
27445                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriverDirectory,
27446                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriverDirectory,
27447                 false,
27448         },
27449         {
27450                 "spoolss_DeletePrinterDriver",
27451                 sizeof(struct spoolss_DeletePrinterDriver),
27452                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriver,
27453                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriver,
27454                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriver,
27455                 false,
27456         },
27457         {
27458                 "spoolss_AddPrintProcessor",
27459                 sizeof(struct spoolss_AddPrintProcessor),
27460                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProcessor,
27461                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProcessor,
27462                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProcessor,
27463                 false,
27464         },
27465         {
27466                 "spoolss_EnumPrintProcessors",
27467                 sizeof(struct spoolss_EnumPrintProcessors),
27468                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcessors,
27469                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcessors,
27470                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcessors,
27471                 false,
27472         },
27473         {
27474                 "spoolss_GetPrintProcessorDirectory",
27475                 sizeof(struct spoolss_GetPrintProcessorDirectory),
27476                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrintProcessorDirectory,
27477                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrintProcessorDirectory,
27478                 (ndr_print_function_t) ndr_print_spoolss_GetPrintProcessorDirectory,
27479                 false,
27480         },
27481         {
27482                 "spoolss_StartDocPrinter",
27483                 sizeof(struct spoolss_StartDocPrinter),
27484                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartDocPrinter,
27485                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartDocPrinter,
27486                 (ndr_print_function_t) ndr_print_spoolss_StartDocPrinter,
27487                 false,
27488         },
27489         {
27490                 "spoolss_StartPagePrinter",
27491                 sizeof(struct spoolss_StartPagePrinter),
27492                 (ndr_push_flags_fn_t) ndr_push_spoolss_StartPagePrinter,
27493                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_StartPagePrinter,
27494                 (ndr_print_function_t) ndr_print_spoolss_StartPagePrinter,
27495                 false,
27496         },
27497         {
27498                 "spoolss_WritePrinter",
27499                 sizeof(struct spoolss_WritePrinter),
27500                 (ndr_push_flags_fn_t) ndr_push_spoolss_WritePrinter,
27501                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WritePrinter,
27502                 (ndr_print_function_t) ndr_print_spoolss_WritePrinter,
27503                 false,
27504         },
27505         {
27506                 "spoolss_EndPagePrinter",
27507                 sizeof(struct spoolss_EndPagePrinter),
27508                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndPagePrinter,
27509                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndPagePrinter,
27510                 (ndr_print_function_t) ndr_print_spoolss_EndPagePrinter,
27511                 false,
27512         },
27513         {
27514                 "spoolss_AbortPrinter",
27515                 sizeof(struct spoolss_AbortPrinter),
27516                 (ndr_push_flags_fn_t) ndr_push_spoolss_AbortPrinter,
27517                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AbortPrinter,
27518                 (ndr_print_function_t) ndr_print_spoolss_AbortPrinter,
27519                 false,
27520         },
27521         {
27522                 "spoolss_ReadPrinter",
27523                 sizeof(struct spoolss_ReadPrinter),
27524                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReadPrinter,
27525                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReadPrinter,
27526                 (ndr_print_function_t) ndr_print_spoolss_ReadPrinter,
27527                 false,
27528         },
27529         {
27530                 "spoolss_EndDocPrinter",
27531                 sizeof(struct spoolss_EndDocPrinter),
27532                 (ndr_push_flags_fn_t) ndr_push_spoolss_EndDocPrinter,
27533                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EndDocPrinter,
27534                 (ndr_print_function_t) ndr_print_spoolss_EndDocPrinter,
27535                 false,
27536         },
27537         {
27538                 "spoolss_AddJob",
27539                 sizeof(struct spoolss_AddJob),
27540                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddJob,
27541                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddJob,
27542                 (ndr_print_function_t) ndr_print_spoolss_AddJob,
27543                 false,
27544         },
27545         {
27546                 "spoolss_ScheduleJob",
27547                 sizeof(struct spoolss_ScheduleJob),
27548                 (ndr_push_flags_fn_t) ndr_push_spoolss_ScheduleJob,
27549                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ScheduleJob,
27550                 (ndr_print_function_t) ndr_print_spoolss_ScheduleJob,
27551                 false,
27552         },
27553         {
27554                 "spoolss_GetPrinterData",
27555                 sizeof(struct spoolss_GetPrinterData),
27556                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterData,
27557                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterData,
27558                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterData,
27559                 false,
27560         },
27561         {
27562                 "spoolss_SetPrinterData",
27563                 sizeof(struct spoolss_SetPrinterData),
27564                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterData,
27565                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterData,
27566                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterData,
27567                 false,
27568         },
27569         {
27570                 "spoolss_WaitForPrinterChange",
27571                 sizeof(struct spoolss_WaitForPrinterChange),
27572                 (ndr_push_flags_fn_t) ndr_push_spoolss_WaitForPrinterChange,
27573                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_WaitForPrinterChange,
27574                 (ndr_print_function_t) ndr_print_spoolss_WaitForPrinterChange,
27575                 false,
27576         },
27577         {
27578                 "spoolss_ClosePrinter",
27579                 sizeof(struct spoolss_ClosePrinter),
27580                 (ndr_push_flags_fn_t) ndr_push_spoolss_ClosePrinter,
27581                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ClosePrinter,
27582                 (ndr_print_function_t) ndr_print_spoolss_ClosePrinter,
27583                 false,
27584         },
27585         {
27586                 "spoolss_AddForm",
27587                 sizeof(struct spoolss_AddForm),
27588                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddForm,
27589                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddForm,
27590                 (ndr_print_function_t) ndr_print_spoolss_AddForm,
27591                 false,
27592         },
27593         {
27594                 "spoolss_DeleteForm",
27595                 sizeof(struct spoolss_DeleteForm),
27596                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteForm,
27597                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteForm,
27598                 (ndr_print_function_t) ndr_print_spoolss_DeleteForm,
27599                 false,
27600         },
27601         {
27602                 "spoolss_GetForm",
27603                 sizeof(struct spoolss_GetForm),
27604                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetForm,
27605                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetForm,
27606                 (ndr_print_function_t) ndr_print_spoolss_GetForm,
27607                 false,
27608         },
27609         {
27610                 "spoolss_SetForm",
27611                 sizeof(struct spoolss_SetForm),
27612                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetForm,
27613                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetForm,
27614                 (ndr_print_function_t) ndr_print_spoolss_SetForm,
27615                 false,
27616         },
27617         {
27618                 "spoolss_EnumForms",
27619                 sizeof(struct spoolss_EnumForms),
27620                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumForms,
27621                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumForms,
27622                 (ndr_print_function_t) ndr_print_spoolss_EnumForms,
27623                 false,
27624         },
27625         {
27626                 "spoolss_EnumPorts",
27627                 sizeof(struct spoolss_EnumPorts),
27628                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPorts,
27629                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPorts,
27630                 (ndr_print_function_t) ndr_print_spoolss_EnumPorts,
27631                 false,
27632         },
27633         {
27634                 "spoolss_EnumMonitors",
27635                 sizeof(struct spoolss_EnumMonitors),
27636                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumMonitors,
27637                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumMonitors,
27638                 (ndr_print_function_t) ndr_print_spoolss_EnumMonitors,
27639                 false,
27640         },
27641         {
27642                 "spoolss_AddPort",
27643                 sizeof(struct spoolss_AddPort),
27644                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPort,
27645                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPort,
27646                 (ndr_print_function_t) ndr_print_spoolss_AddPort,
27647                 false,
27648         },
27649         {
27650                 "spoolss_ConfigurePort",
27651                 sizeof(struct spoolss_ConfigurePort),
27652                 (ndr_push_flags_fn_t) ndr_push_spoolss_ConfigurePort,
27653                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ConfigurePort,
27654                 (ndr_print_function_t) ndr_print_spoolss_ConfigurePort,
27655                 false,
27656         },
27657         {
27658                 "spoolss_DeletePort",
27659                 sizeof(struct spoolss_DeletePort),
27660                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePort,
27661                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePort,
27662                 (ndr_print_function_t) ndr_print_spoolss_DeletePort,
27663                 false,
27664         },
27665         {
27666                 "spoolss_CreatePrinterIC",
27667                 sizeof(struct spoolss_CreatePrinterIC),
27668                 (ndr_push_flags_fn_t) ndr_push_spoolss_CreatePrinterIC,
27669                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_CreatePrinterIC,
27670                 (ndr_print_function_t) ndr_print_spoolss_CreatePrinterIC,
27671                 false,
27672         },
27673         {
27674                 "spoolss_PlayGDIScriptOnPrinterIC",
27675                 sizeof(struct spoolss_PlayGDIScriptOnPrinterIC),
27676                 (ndr_push_flags_fn_t) ndr_push_spoolss_PlayGDIScriptOnPrinterIC,
27677                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PlayGDIScriptOnPrinterIC,
27678                 (ndr_print_function_t) ndr_print_spoolss_PlayGDIScriptOnPrinterIC,
27679                 false,
27680         },
27681         {
27682                 "spoolss_DeletePrinterIC",
27683                 sizeof(struct spoolss_DeletePrinterIC),
27684                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterIC,
27685                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterIC,
27686                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterIC,
27687                 false,
27688         },
27689         {
27690                 "spoolss_AddPrinterConnection",
27691                 sizeof(struct spoolss_AddPrinterConnection),
27692                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterConnection,
27693                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterConnection,
27694                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterConnection,
27695                 false,
27696         },
27697         {
27698                 "spoolss_DeletePrinterConnection",
27699                 sizeof(struct spoolss_DeletePrinterConnection),
27700                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterConnection,
27701                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterConnection,
27702                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterConnection,
27703                 false,
27704         },
27705         {
27706                 "spoolss_PrinterMessageBox",
27707                 sizeof(struct spoolss_PrinterMessageBox),
27708                 (ndr_push_flags_fn_t) ndr_push_spoolss_PrinterMessageBox,
27709                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_PrinterMessageBox,
27710                 (ndr_print_function_t) ndr_print_spoolss_PrinterMessageBox,
27711                 false,
27712         },
27713         {
27714                 "spoolss_AddMonitor",
27715                 sizeof(struct spoolss_AddMonitor),
27716                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddMonitor,
27717                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddMonitor,
27718                 (ndr_print_function_t) ndr_print_spoolss_AddMonitor,
27719                 false,
27720         },
27721         {
27722                 "spoolss_DeleteMonitor",
27723                 sizeof(struct spoolss_DeleteMonitor),
27724                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeleteMonitor,
27725                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeleteMonitor,
27726                 (ndr_print_function_t) ndr_print_spoolss_DeleteMonitor,
27727                 false,
27728         },
27729         {
27730                 "spoolss_DeletePrintProcessor",
27731                 sizeof(struct spoolss_DeletePrintProcessor),
27732                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProcessor,
27733                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProcessor,
27734                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProcessor,
27735                 false,
27736         },
27737         {
27738                 "spoolss_AddPrintProvidor",
27739                 sizeof(struct spoolss_AddPrintProvidor),
27740                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrintProvidor,
27741                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrintProvidor,
27742                 (ndr_print_function_t) ndr_print_spoolss_AddPrintProvidor,
27743                 false,
27744         },
27745         {
27746                 "spoolss_DeletePrintProvidor",
27747                 sizeof(struct spoolss_DeletePrintProvidor),
27748                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrintProvidor,
27749                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrintProvidor,
27750                 (ndr_print_function_t) ndr_print_spoolss_DeletePrintProvidor,
27751                 false,
27752         },
27753         {
27754                 "spoolss_EnumPrintProcDataTypes",
27755                 sizeof(struct spoolss_EnumPrintProcDataTypes),
27756                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrintProcDataTypes,
27757                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrintProcDataTypes,
27758                 (ndr_print_function_t) ndr_print_spoolss_EnumPrintProcDataTypes,
27759                 false,
27760         },
27761         {
27762                 "spoolss_ResetPrinter",
27763                 sizeof(struct spoolss_ResetPrinter),
27764                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinter,
27765                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinter,
27766                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinter,
27767                 false,
27768         },
27769         {
27770                 "spoolss_GetPrinterDriver2",
27771                 sizeof(struct spoolss_GetPrinterDriver2),
27772                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDriver2,
27773                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDriver2,
27774                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDriver2,
27775                 false,
27776         },
27777         {
27778                 "spoolss_FindFirstPrinterChangeNotification",
27779                 sizeof(struct spoolss_FindFirstPrinterChangeNotification),
27780                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindFirstPrinterChangeNotification,
27781                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindFirstPrinterChangeNotification,
27782                 (ndr_print_function_t) ndr_print_spoolss_FindFirstPrinterChangeNotification,
27783                 false,
27784         },
27785         {
27786                 "spoolss_FindNextPrinterChangeNotification",
27787                 sizeof(struct spoolss_FindNextPrinterChangeNotification),
27788                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindNextPrinterChangeNotification,
27789                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindNextPrinterChangeNotification,
27790                 (ndr_print_function_t) ndr_print_spoolss_FindNextPrinterChangeNotification,
27791                 false,
27792         },
27793         {
27794                 "spoolss_FindClosePrinterNotify",
27795                 sizeof(struct spoolss_FindClosePrinterNotify),
27796                 (ndr_push_flags_fn_t) ndr_push_spoolss_FindClosePrinterNotify,
27797                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_FindClosePrinterNotify,
27798                 (ndr_print_function_t) ndr_print_spoolss_FindClosePrinterNotify,
27799                 false,
27800         },
27801         {
27802                 "spoolss_RouterFindFirstPrinterChangeNotificationOld",
27803                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotificationOld),
27804                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27805                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27806                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotificationOld,
27807                 false,
27808         },
27809         {
27810                 "spoolss_ReplyOpenPrinter",
27811                 sizeof(struct spoolss_ReplyOpenPrinter),
27812                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyOpenPrinter,
27813                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyOpenPrinter,
27814                 (ndr_print_function_t) ndr_print_spoolss_ReplyOpenPrinter,
27815                 false,
27816         },
27817         {
27818                 "spoolss_RouterReplyPrinter",
27819                 sizeof(struct spoolss_RouterReplyPrinter),
27820                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinter,
27821                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinter,
27822                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinter,
27823                 false,
27824         },
27825         {
27826                 "spoolss_ReplyClosePrinter",
27827                 sizeof(struct spoolss_ReplyClosePrinter),
27828                 (ndr_push_flags_fn_t) ndr_push_spoolss_ReplyClosePrinter,
27829                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ReplyClosePrinter,
27830                 (ndr_print_function_t) ndr_print_spoolss_ReplyClosePrinter,
27831                 false,
27832         },
27833         {
27834                 "spoolss_AddPortEx",
27835                 sizeof(struct spoolss_AddPortEx),
27836                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPortEx,
27837                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPortEx,
27838                 (ndr_print_function_t) ndr_print_spoolss_AddPortEx,
27839                 false,
27840         },
27841         {
27842                 "spoolss_RouterFindFirstPrinterChangeNotification",
27843                 sizeof(struct spoolss_RouterFindFirstPrinterChangeNotification),
27844                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterFindFirstPrinterChangeNotification,
27845                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterFindFirstPrinterChangeNotification,
27846                 (ndr_print_function_t) ndr_print_spoolss_RouterFindFirstPrinterChangeNotification,
27847                 false,
27848         },
27849         {
27850                 "spoolss_SpoolerInit",
27851                 sizeof(struct spoolss_SpoolerInit),
27852                 (ndr_push_flags_fn_t) ndr_push_spoolss_SpoolerInit,
27853                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SpoolerInit,
27854                 (ndr_print_function_t) ndr_print_spoolss_SpoolerInit,
27855                 false,
27856         },
27857         {
27858                 "spoolss_ResetPrinterEx",
27859                 sizeof(struct spoolss_ResetPrinterEx),
27860                 (ndr_push_flags_fn_t) ndr_push_spoolss_ResetPrinterEx,
27861                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_ResetPrinterEx,
27862                 (ndr_print_function_t) ndr_print_spoolss_ResetPrinterEx,
27863                 false,
27864         },
27865         {
27866                 "spoolss_RemoteFindFirstPrinterChangeNotifyEx",
27867                 sizeof(struct spoolss_RemoteFindFirstPrinterChangeNotifyEx),
27868                 (ndr_push_flags_fn_t) ndr_push_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27869                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27870                 (ndr_print_function_t) ndr_print_spoolss_RemoteFindFirstPrinterChangeNotifyEx,
27871                 false,
27872         },
27873         {
27874                 "spoolss_RouterReplyPrinterEx",
27875                 sizeof(struct spoolss_RouterReplyPrinterEx),
27876                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterReplyPrinterEx,
27877                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterReplyPrinterEx,
27878                 (ndr_print_function_t) ndr_print_spoolss_RouterReplyPrinterEx,
27879                 false,
27880         },
27881         {
27882                 "spoolss_RouterRefreshPrinterChangeNotify",
27883                 sizeof(struct spoolss_RouterRefreshPrinterChangeNotify),
27884                 (ndr_push_flags_fn_t) ndr_push_spoolss_RouterRefreshPrinterChangeNotify,
27885                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_RouterRefreshPrinterChangeNotify,
27886                 (ndr_print_function_t) ndr_print_spoolss_RouterRefreshPrinterChangeNotify,
27887                 false,
27888         },
27889         {
27890                 "spoolss_44",
27891                 sizeof(struct spoolss_44),
27892                 (ndr_push_flags_fn_t) ndr_push_spoolss_44,
27893                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_44,
27894                 (ndr_print_function_t) ndr_print_spoolss_44,
27895                 false,
27896         },
27897         {
27898                 "spoolss_OpenPrinterEx",
27899                 sizeof(struct spoolss_OpenPrinterEx),
27900                 (ndr_push_flags_fn_t) ndr_push_spoolss_OpenPrinterEx,
27901                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_OpenPrinterEx,
27902                 (ndr_print_function_t) ndr_print_spoolss_OpenPrinterEx,
27903                 false,
27904         },
27905         {
27906                 "spoolss_AddPrinterEx",
27907                 sizeof(struct spoolss_AddPrinterEx),
27908                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterEx,
27909                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterEx,
27910                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterEx,
27911                 false,
27912         },
27913         {
27914                 "spoolss_47",
27915                 sizeof(struct spoolss_47),
27916                 (ndr_push_flags_fn_t) ndr_push_spoolss_47,
27917                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_47,
27918                 (ndr_print_function_t) ndr_print_spoolss_47,
27919                 false,
27920         },
27921         {
27922                 "spoolss_EnumPrinterData",
27923                 sizeof(struct spoolss_EnumPrinterData),
27924                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterData,
27925                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterData,
27926                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterData,
27927                 false,
27928         },
27929         {
27930                 "spoolss_DeletePrinterData",
27931                 sizeof(struct spoolss_DeletePrinterData),
27932                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterData,
27933                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterData,
27934                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterData,
27935                 false,
27936         },
27937         {
27938                 "spoolss_4a",
27939                 sizeof(struct spoolss_4a),
27940                 (ndr_push_flags_fn_t) ndr_push_spoolss_4a,
27941                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4a,
27942                 (ndr_print_function_t) ndr_print_spoolss_4a,
27943                 false,
27944         },
27945         {
27946                 "spoolss_4b",
27947                 sizeof(struct spoolss_4b),
27948                 (ndr_push_flags_fn_t) ndr_push_spoolss_4b,
27949                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4b,
27950                 (ndr_print_function_t) ndr_print_spoolss_4b,
27951                 false,
27952         },
27953         {
27954                 "spoolss_4c",
27955                 sizeof(struct spoolss_4c),
27956                 (ndr_push_flags_fn_t) ndr_push_spoolss_4c,
27957                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_4c,
27958                 (ndr_print_function_t) ndr_print_spoolss_4c,
27959                 false,
27960         },
27961         {
27962                 "spoolss_SetPrinterDataEx",
27963                 sizeof(struct spoolss_SetPrinterDataEx),
27964                 (ndr_push_flags_fn_t) ndr_push_spoolss_SetPrinterDataEx,
27965                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_SetPrinterDataEx,
27966                 (ndr_print_function_t) ndr_print_spoolss_SetPrinterDataEx,
27967                 false,
27968         },
27969         {
27970                 "spoolss_GetPrinterDataEx",
27971                 sizeof(struct spoolss_GetPrinterDataEx),
27972                 (ndr_push_flags_fn_t) ndr_push_spoolss_GetPrinterDataEx,
27973                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_GetPrinterDataEx,
27974                 (ndr_print_function_t) ndr_print_spoolss_GetPrinterDataEx,
27975                 false,
27976         },
27977         {
27978                 "spoolss_EnumPrinterDataEx",
27979                 sizeof(struct spoolss_EnumPrinterDataEx),
27980                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterDataEx,
27981                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterDataEx,
27982                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterDataEx,
27983                 false,
27984         },
27985         {
27986                 "spoolss_EnumPrinterKey",
27987                 sizeof(struct spoolss_EnumPrinterKey),
27988                 (ndr_push_flags_fn_t) ndr_push_spoolss_EnumPrinterKey,
27989                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_EnumPrinterKey,
27990                 (ndr_print_function_t) ndr_print_spoolss_EnumPrinterKey,
27991                 false,
27992         },
27993         {
27994                 "spoolss_DeletePrinterDataEx",
27995                 sizeof(struct spoolss_DeletePrinterDataEx),
27996                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDataEx,
27997                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDataEx,
27998                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDataEx,
27999                 false,
28000         },
28001         {
28002                 "spoolss_DeletePrinterKey",
28003                 sizeof(struct spoolss_DeletePrinterKey),
28004                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterKey,
28005                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterKey,
28006                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterKey,
28007                 false,
28008         },
28009         {
28010                 "spoolss_53",
28011                 sizeof(struct spoolss_53),
28012                 (ndr_push_flags_fn_t) ndr_push_spoolss_53,
28013                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_53,
28014                 (ndr_print_function_t) ndr_print_spoolss_53,
28015                 false,
28016         },
28017         {
28018                 "spoolss_DeletePrinterDriverEx",
28019                 sizeof(struct spoolss_DeletePrinterDriverEx),
28020                 (ndr_push_flags_fn_t) ndr_push_spoolss_DeletePrinterDriverEx,
28021                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_DeletePrinterDriverEx,
28022                 (ndr_print_function_t) ndr_print_spoolss_DeletePrinterDriverEx,
28023                 false,
28024         },
28025         {
28026                 "spoolss_55",
28027                 sizeof(struct spoolss_55),
28028                 (ndr_push_flags_fn_t) ndr_push_spoolss_55,
28029                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_55,
28030                 (ndr_print_function_t) ndr_print_spoolss_55,
28031                 false,
28032         },
28033         {
28034                 "spoolss_56",
28035                 sizeof(struct spoolss_56),
28036                 (ndr_push_flags_fn_t) ndr_push_spoolss_56,
28037                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_56,
28038                 (ndr_print_function_t) ndr_print_spoolss_56,
28039                 false,
28040         },
28041         {
28042                 "spoolss_57",
28043                 sizeof(struct spoolss_57),
28044                 (ndr_push_flags_fn_t) ndr_push_spoolss_57,
28045                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_57,
28046                 (ndr_print_function_t) ndr_print_spoolss_57,
28047                 false,
28048         },
28049         {
28050                 "spoolss_XcvData",
28051                 sizeof(struct spoolss_XcvData),
28052                 (ndr_push_flags_fn_t) ndr_push_spoolss_XcvData,
28053                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_XcvData,
28054                 (ndr_print_function_t) ndr_print_spoolss_XcvData,
28055                 false,
28056         },
28057         {
28058                 "spoolss_AddPrinterDriverEx",
28059                 sizeof(struct spoolss_AddPrinterDriverEx),
28060                 (ndr_push_flags_fn_t) ndr_push_spoolss_AddPrinterDriverEx,
28061                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_AddPrinterDriverEx,
28062                 (ndr_print_function_t) ndr_print_spoolss_AddPrinterDriverEx,
28063                 false,
28064         },
28065         {
28066                 "spoolss_5a",
28067                 sizeof(struct spoolss_5a),
28068                 (ndr_push_flags_fn_t) ndr_push_spoolss_5a,
28069                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5a,
28070                 (ndr_print_function_t) ndr_print_spoolss_5a,
28071                 false,
28072         },
28073         {
28074                 "spoolss_5b",
28075                 sizeof(struct spoolss_5b),
28076                 (ndr_push_flags_fn_t) ndr_push_spoolss_5b,
28077                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5b,
28078                 (ndr_print_function_t) ndr_print_spoolss_5b,
28079                 false,
28080         },
28081         {
28082                 "spoolss_5c",
28083                 sizeof(struct spoolss_5c),
28084                 (ndr_push_flags_fn_t) ndr_push_spoolss_5c,
28085                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5c,
28086                 (ndr_print_function_t) ndr_print_spoolss_5c,
28087                 false,
28088         },
28089         {
28090                 "spoolss_5d",
28091                 sizeof(struct spoolss_5d),
28092                 (ndr_push_flags_fn_t) ndr_push_spoolss_5d,
28093                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5d,
28094                 (ndr_print_function_t) ndr_print_spoolss_5d,
28095                 false,
28096         },
28097         {
28098                 "spoolss_5e",
28099                 sizeof(struct spoolss_5e),
28100                 (ndr_push_flags_fn_t) ndr_push_spoolss_5e,
28101                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5e,
28102                 (ndr_print_function_t) ndr_print_spoolss_5e,
28103                 false,
28104         },
28105         {
28106                 "spoolss_5f",
28107                 sizeof(struct spoolss_5f),
28108                 (ndr_push_flags_fn_t) ndr_push_spoolss_5f,
28109                 (ndr_pull_flags_fn_t) ndr_pull_spoolss_5f,
28110                 (ndr_print_function_t) ndr_print_spoolss_5f,
28111                 false,
28112         },
28113         { NULL, 0, NULL, NULL, NULL, false }
28114 };
28115
28116 static const char * const spoolss_endpoint_strings[] = {
28117         "ncacn_np:[\\pipe\\spoolss]",
28118 };
28119
28120 static const struct ndr_interface_string_array spoolss_endpoints = {
28121         .count  = 1,
28122         .names  = spoolss_endpoint_strings
28123 };
28124
28125 static const char * const spoolss_authservice_strings[] = {
28126         "host",
28127 };
28128
28129 static const struct ndr_interface_string_array spoolss_authservices = {
28130         .count  = 1,
28131         .names  = spoolss_authservice_strings
28132 };
28133
28134
28135 const struct ndr_interface_table ndr_table_spoolss = {
28136         .name           = "spoolss",
28137         .syntax_id      = {
28138                 {0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},
28139                 NDR_SPOOLSS_VERSION
28140         },
28141         .helpstring     = NDR_SPOOLSS_HELPSTRING,
28142         .num_calls      = 96,
28143         .calls          = spoolss_calls,
28144         .endpoints      = &spoolss_endpoints,
28145         .authservices   = &spoolss_authservices
28146 };
28147